From fbefc71bf22a328446d34bc359ea1b17fd817a15 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:19:40 +0000
Subject: [PATCH 01/23] Thread preflight on by default for eval launches; log
 and record every loosened value

The C1b eval scripts passed --preflight-threads off. They now keep the
default (wait) and may loosen it only with explicit flags (cfg
preflight_args / PREFLIGHT env); the launcher prints each loosened value
with its default and records it under preflight.threads.relaxed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_launch_preflight_guards.py | 27 ++++++++++++++++++++++++++-
 tools/eval/miles.py                   |  8 +++++---
 tools/eval/miles_head.sh              |  7 +++++--
 yeto/launch_preflight.py              | 27 +++++++++++++++++++++++++--
 4 files changed, 61 insertions(+), 8 deletions(-)

diff --git a/tests/test_launch_preflight_guards.py b/tests/test_launch_preflight_guards.py
index ab9be398..c8d9ee6f 100644
--- a/tests/test_launch_preflight_guards.py
+++ b/tests/test_launch_preflight_guards.py
@@ -143,7 +143,32 @@ def test_threads_off_skips_and_warns():
     out = io.StringIO()
     rec = lp.thread_preflight(_targs(preflight_threads="off"),
                               counter=lambda: pytest.fail("off must not read"), out=out)
-    assert rec == {"mode": "off", "disabled": True} and "OFF" in out.getvalue()
+    assert rec == {"mode": "off", "disabled": True, "relaxed": {"mode": ["off", "wait"]}}
+    assert "OFF" in out.getvalue() and "RELAXED" in out.getvalue()
+
+
+def test_threads_default_is_on_and_not_relaxed():
+    out = io.StringIO()
+    rec = lp.thread_preflight(_targs(), counter=_counter([100]), out=out)
+    assert rec["mode"] == "wait" and rec["relaxed"] == {} and "RELAXED" not in out.getvalue()
+
+
+def test_threads_loosened_values_are_logged_and_recorded():
+    out = io.StringIO()
+    rec = lp.thread_preflight(_targs(preflight_thread_start=2950, preflight_thread_hard=3200),
+                              counter=_counter([2900]), out=out)
+    assert rec["relaxed"] == {"start": [2950, 2800], "hard": [3200, 3000]}
+    assert "start 2950 (default 2800)" in out.getvalue() and "hard 3200 (default 3000)" in out.getvalue()
+    # a stricter setting is not a relaxation
+    assert lp.thread_relaxations(lp.ThreadConfig(mode="error", start=100, hard=200)) == {}
+
+
+def test_eval_launch_args_keep_the_thread_preflight_on():
+    from pathlib import Path
+    from tools.eval import miles
+    root = Path(__file__).resolve().parents[1]
+    assert "--preflight-threads off" not in (root / "tools/eval/miles_head.sh").read_text()
+    assert "--preflight-threads off" not in Path(miles.__file__).read_text()
 
 
 def test_thread_message_text():
diff --git a/tools/eval/miles.py b/tools/eval/miles.py
index 3f9538e6..401e3fae 100644
--- a/tools/eval/miles.py
+++ b/tools/eval/miles.py
@@ -30,9 +30,11 @@ def _gpu(cfg: dict, n: int) -> str:
 
 
 def _common(cfg: dict, run_id: str, prefix: str) -> str:
-    # --preflight-threads off: Modal islands put no SkyPilot threads on this host; the scripts
-    # check the host thread count (< 3000) before the launch instead
-    return (f"launch --training-mode rl --rl-engine ports --preflight-threads off "
+    # the launcher thread preflight stays on (default wait); a cell may loosen it only with
+    # explicit flags in cfg["preflight_args"] (e.g. "--preflight-thread-start 2950"), which the
+    # launcher prints and records in the run manifest
+    preflight = cfg.get("preflight_args", "")
+    return (f"launch --training-mode rl --rl-engine ports {preflight + ' ' if preflight else ''}"
             f"--modal-gpu-exact --modal-retries 0 --modal-cpu 8 "
             f"--modal-memory 64 --modal-tape-volume {TAPE_VOLUME} --controller local --cluster-prefix {prefix} "
             f"--tuning lora --lora-r {cfg['lora_r']} --rl-observe-timeline {MODEL} {DATA} "
diff --git a/tools/eval/miles_head.sh b/tools/eval/miles_head.sh
index dac65373..e4ac5b03 100755
--- a/tools/eval/miles_head.sh
+++ b/tools/eval/miles_head.sh
@@ -8,6 +8,9 @@
 set -u
 : "${P:?}" "${R:?}" "${REPO:?}" "${PY:?}" "${SKY:?}"
 HARD=${HARD:-2700}; WD=$(( HARD + 300 )); STEPS=${STEPS:-4}; SROUNDS=$(( 2 * STEPS + 6 )); GPU=${GPU:-a10g}
+# launcher thread preflight stays on; loosen only with explicit flags, e.g.
+# PREFLIGHT="--preflight-thread-start 2950" (the launcher logs and records the loosened values)
+PREFLIGHT=${PREFLIGHT:-}
 SHA=${SHA:-HEAD}; MODAL="$PY -m modal"
 APP=yeto-$P; SP=$P-s; SAPP=yeto-$SP; TAPEVOL=yeto-event-tapes; STOREVOL=${STOREVOL:-yeto-eval-store}; HEAD_REGION=nebius/eu-north1
 export CARGO_HOME=/home/michael/work/gpu-default-modal/cargo RUSTUP_HOME=/home/michael/work/gpu-default-modal/rustup
@@ -30,8 +33,8 @@ LORA="--tuning lora --lora-r 16"
 MODALX="--modal-gpu-exact --modal-retries 0 --modal-cpu 8 --modal-memory 64 --modal-tape-volume $TAPEVOL"
 STORE="--rl-checkpoint-store modal-volume://$STOREVOL/$P"
 COMMON="--training-mode rl --rl-engine ports $MODALX $MODEL $DATA $LORA $STORE --rl-algorithm-spec examples/rl_algorithms/decoupled-ppo-c2.json --rl-max-policy-age 2 --rl-observe-timeline --reward-function gsm8k_reward:score --fragments 1 --pipeline 1 --rollout-batch-size 32 --n-samples-per-prompt 4 --rollout-max-response-len 1024 --seq-len 2048 --inner-lr 1e-5 --seed 17 --apply-chat-template-kwargs '{\"enable_thinking\": false}' --trust-remote-code"
-TARGS="launch --controller head --syncer-region $HEAD_REGION --preflight-threads off --rl-stall-timeout 2400 --on-demand --no-island-relaunch --modal-timeout-s $HARD --cluster-prefix $P --gpu modal:1x$GPU,modal:1x$GPU --rl-island-scheduling elastic --rl-sample-role trainer --rl-sample-wait-s 900 $COMMON --total-steps $STEPS"
-SARGS="launch --preflight-threads off --controller local --cluster-prefix $SP --gpu modal:1x$GPU --rl-single-island-no-sync --rl-sample-role sampler --rl-sampler-max-backlog-rounds 4 $COMMON --total-steps $SROUNDS"
+TARGS="launch --controller head --syncer-region $HEAD_REGION $PREFLIGHT --rl-stall-timeout 2400 --on-demand --no-island-relaunch --modal-timeout-s $HARD --cluster-prefix $P --gpu modal:1x$GPU,modal:1x$GPU --rl-island-scheduling elastic --rl-sample-role trainer --rl-sample-wait-s 900 $COMMON --total-steps $STEPS"
+SARGS="launch $PREFLIGHT --controller local --cluster-prefix $SP --gpu modal:1x$GPU --rl-single-island-no-sync --rl-sample-role sampler --rl-sampler-max-backlog-rounds 4 $COMMON --total-steps $SROUNDS"
 git -C $REPO rev-parse $SHA > $R/yeto_sha.txt; echo "$TARGS" > $R/args.txt; echo "$SARGS" > $R/sargs.txt
 echo "$APP $SAPP $HEAD_CL" > $R/resources.txt
 eval "$(/usr/bin/python3 - <<'PYC'
diff --git a/yeto/launch_preflight.py b/yeto/launch_preflight.py
index 539b07a0..c173c4da 100644
--- a/yeto/launch_preflight.py
+++ b/yeto/launch_preflight.py
@@ -185,6 +185,24 @@ def thread_message(count: ThreadCount, cfg: ThreadConfig, headline: str) -> str:
     ])
 
 
+def thread_relaxations(cfg: ThreadConfig) -> dict:
+    """The thread settings that are looser than the defaults, as ``{name: [value, default]}``.
+
+    The check is on by default; a run may only loosen it with an explicit flag, and the
+    launcher prints and records every loosened value (empty dict: defaults or stricter)."""
+
+    relaxed = {}
+    if cfg.mode == "off":
+        relaxed["mode"] = ["off", DEFAULT_THREAD_MODE]
+    if cfg.start > DEFAULT_THREAD_START:
+        relaxed["start"] = [cfg.start, DEFAULT_THREAD_START]
+    if cfg.hard > DEFAULT_THREAD_HARD:
+        relaxed["hard"] = [cfg.hard, DEFAULT_THREAD_HARD]
+    if cfg.mode == "wait" and cfg.wait_s > DEFAULT_THREAD_WAIT_S:
+        relaxed["wait_s"] = [cfg.wait_s, DEFAULT_THREAD_WAIT_S]
+    return relaxed
+
+
 def thread_preflight(args, *, counter: Callable[[], ThreadCount] | None = None,
                      clock: Callable[[], float] = time.monotonic,
                      sleep: Callable[[float], None] = time.sleep,
@@ -197,10 +215,15 @@ def thread_preflight(args, *, counter: Callable[[], ThreadCount] | None = None,
 
     out = sys.stderr if out is None else out
     cfg = ThreadConfig.from_args(args)
+    relaxed = thread_relaxations(cfg)
+    if relaxed:
+        print("[preflight] WARNING: thread preflight RELAXED by explicit flags: "
+              + ", ".join(f"{k} {v[0]} (default {v[1]})" for k, v in relaxed.items()),
+              file=out, flush=True)
     if cfg.mode == "off":
         print("[preflight] WARNING: thread preflight is OFF (--preflight-threads off); the "
               "s1run thread guard may tear down this run", file=out, flush=True)
-        return {"mode": "off", "disabled": True}
+        return {"mode": "off", "disabled": True, "relaxed": relaxed}
     counter = counter or count_threads
     started = clock()
     count = counter()
@@ -233,7 +256,7 @@ def thread_preflight(args, *, counter: Callable[[], ThreadCount] | None = None,
           f"(SkyPilot API server {count.sky_api if count.sky_api_found else 'not found'})",
           file=out, flush=True)
     return {"mode": cfg.mode, "start": cfg.start, "hard": cfg.hard, "wait_s": cfg.wait_s,
-            "waited": waited, "readings": readings, **count.to_dict()}
+            "waited": waited, "readings": readings, "relaxed": relaxed, **count.to_dict()}
 
 
 # ---------------------------------------------------------------------------

From 59ab2b492d934e204783889282d4bdab521a3e13 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:28:54 +0000
Subject: [PATCH 02/23] Samplers draw disjoint data slots; trainer ends
 FINISHED on an exhausted buffer; launcher follows rescheduled Modal
 containers

- sample_roles.DataSlot: sampler i of n keeps prompt rows r % n == i. The
  launcher sets --rl-sampler-data-slot per pair sampler island; the Miles
  buffer writer splits its RolloutDataSource before the first draw and any
  resume seek; the engine sampler spec takes prompts.data_slot (stage 1
  sets it with several sampler nodes).
- BatchReader raises SampleBufferExhausted when the buffer ended with no
  trainable group; IslandDriver ends the run FINISHED before that round
  (event rl_buffer_exhausted), except under a strict roster.
- ContainerLogFollower: when a new container is expected, the launcher
  lists the app's containers and streams each new one's log
  ('modal container logs'), with a warning; the call log stream misses it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_data_slots.py               | 273 ++++++++++++++++++
 yeto/launch/modal_islands.py                  |  17 ++
 yeto/launcher.py                              |  13 +-
 yeto/modal_runner.py                          | 101 +++++++
 yeto/rl/adapters/miles/buffer_rollout.py      |  44 ++-
 .../rl/adapters/miles/buffer_rollout_miles.py |   6 +
 yeto/rl/adapters/miles/island_entry.py        |   2 +-
 yeto/rl/engine/bridges.py                     |   8 +
 yeto/rl/engine/buffer_payload.py              |  24 ++
 yeto/rl/engine/driver.py                      |  13 +-
 yeto/rl/engine/engine_sampler_entry.py        |  26 +-
 yeto/rl/engine/run_flags.py                   |   3 +
 yeto/rl/engine/sample_roles.py                |  51 ++++
 yeto/rl/stage1.py                             |  12 +-
 14 files changed, 575 insertions(+), 18 deletions(-)
 create mode 100644 tests/test_s26_e9_data_slots.py

diff --git a/tests/test_s26_e9_data_slots.py b/tests/test_s26_e9_data_slots.py
new file mode 100644
index 00000000..8609d4d8
--- /dev/null
+++ b/tests/test_s26_e9_data_slots.py
@@ -0,0 +1,273 @@
+"""S26 E9.3: disjoint sampler data slots, a normal trainer end on an exhausted
+buffer, and the launcher following a rescheduled Modal container's log."""
+
+from __future__ import annotations
+
+import io
+import json
+import random
+import sys
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from yeto.rl.engine import sample_roles
+from yeto.rl.engine.buffer_payload import SampleBufferExhausted, SampleBufferRolloutError, is_buffer_exhausted
+from yeto.rl.engine.engine_sampler_entry import JsonlPrompts, SamplerSpecError
+from yeto.rl.engine.sample_roles import DataSlot
+
+
+# ------------------------------------------------------------------ DataSlot
+def test_data_slot_parse_and_rows():
+    assert DataSlot.parse(None) == DataSlot() and DataSlot().whole
+    slot = DataSlot.parse("1/3")
+    assert (slot.index, slot.count, slot.env()) == (1, 3, "1/3")
+    assert slot.rows(list(range(10))) == [1, 4, 7]
+    for bad in ("3/3", "-1/2", "1/0", "2"):
+        with pytest.raises(ValueError):
+            DataSlot.parse(bad)
+    with pytest.raises(ValueError, match="empty"):
+        DataSlot(2, 3).rows([0, 1])
+
+
+def test_slots_of_all_samplers_cover_the_data_once():
+    rows = list(range(17))
+    drawn = [r for k in range(3) for r in DataSlot(k, 3).rows(rows)]
+    assert sorted(drawn) == rows
+
+
+def test_pair_island_args_give_each_sampler_its_slot_and_flag():
+    pair = SimpleNamespace(rl_island_sample_role=["0:sampler", "1:sampler", "2:trainer"],
+                           rl_sampler_max_backlog_rounds=None, rl_sample_wait_s=None, total_steps=8,
+                           rl_sampler_spot=False)
+    a0, a1, t = (sample_roles.island_args(pair, m, 3) for m in range(3))
+    assert (a0.rl_sampler_data_slot, a1.rl_sampler_data_slot) == ("0/2", "1/2")
+    assert getattr(t, "rl_sampler_data_slot", None) is None
+    assert " --rl-sampler-data-slot 1/2" in sample_roles.island_flags(a1)
+    one = SimpleNamespace(rl_island_sample_role=["0:sampler", "1:trainer"], rl_sampler_max_backlog_rounds=None,
+                          rl_sample_wait_s=None, total_steps=8, rl_sampler_spot=False)
+    assert sample_roles.island_args(one, 0, 2).rl_sampler_data_slot is None  # one sampler: the whole data
+
+
+def test_data_slot_flag_on_both_layers():
+    import argparse
+
+    from yeto.rl.engine.run_flags import CLI, ISLAND, flags_for
+
+    for layer in (CLI, ISLAND):
+        parser = argparse.ArgumentParser()
+        for flag in flags_for(layer):
+            if flag.options[0] == "--rl-sampler-data-slot":
+                parser.add_argument(*flag.options, **dict(flag.kwargs))
+        assert parser.parse_args(["--rl-sampler-data-slot", "0/2"]).rl_sampler_data_slot == "0/2"
+
+
+# ------------------------------------------------------------ engine sampler
+def _prompts(tmp_path, n=10):
+    path = tmp_path / "p.jsonl"
+    path.write_text("".join(json.dumps({"q": f"q{i}", "a": str(i)}) + "\n" for i in range(n)))
+    return path
+
+
+def test_engine_sampler_prompts_of_two_slots_are_disjoint(tmp_path):
+    path = _prompts(tmp_path)
+    ids = []
+    for slot in ("0/2", "1/2"):
+        prompts = JsonlPrompts(path, input_key="q", label_key="a", groups_per_round=2, data_slot=slot)
+        ids.append([item.prompt_id for r in range(2) for item in prompts(r)])
+    assert ids == [["row0", "row2", "row4", "row6"], ["row1", "row3", "row5", "row7"]]
+    whole = JsonlPrompts(path, input_key="q", label_key="a", groups_per_round=2)
+    assert [i.prompt_id for i in whole(1)] == ["row2", "row3"]  # unchanged without a slot
+    with pytest.raises(SamplerSpecError, match="data_slot"):
+        JsonlPrompts(path, input_key="q", label_key="a", groups_per_round=2, data_slot="2/2")
+
+
+def test_stage1_sampler_spec_carries_the_slot_only_with_several_samplers():
+    from yeto.rl import stage1
+
+    src = open(stage1.__file__).read()
+    assert "slot=DataSlot(samplers.index(node)" in src and '"data_slot": slot.env()' in src
+
+
+# --------------------------------------------------------------- Miles source
+class _FakeDataset:
+    """The fields and shuffle of Miles' ``miles.utils.data.Dataset``."""
+
+    def __init__(self, rows, seed=3):
+        self.origin_samples = list(rows)
+        self.samples = list(rows)
+        self.seed, self.epoch_id = seed, -1
+
+    def shuffle(self, new_epoch_id):
+        if self.epoch_id == new_epoch_id:
+            return
+        random.seed(self.seed + new_epoch_id)
+        permutation = list(range(len(self.samples)))
+        random.shuffle(permutation)
+        self.samples = [self.origin_samples[i] for i in permutation]
+        self.epoch_id = new_epoch_id
+
+    def __len__(self):
+        return len(self.samples)
+
+
+def _source(rows, shuffle):
+    source = SimpleNamespace(dataset=_FakeDataset(rows), epoch_id=0, sample_offset=0, sample_group_index=0,
+                             sample_index=0)
+    if shuffle:
+        source.dataset.shuffle(0)
+    return source
+
+
+@pytest.mark.parametrize("shuffle", [False, True])
+def test_miles_data_source_slots_are_disjoint(shuffle):
+    from yeto.rl.adapters.miles.buffer_rollout import apply_data_slot
+
+    rows = list(range(20))
+    drawn = []
+    for k in range(2):
+        source = _source(rows, shuffle)
+        assert apply_data_slot(source, DataSlot(k, 2), shuffle=shuffle) == 10
+        assert sorted(source.dataset.samples) == rows[k::2]
+        drawn.append(set(source.dataset.samples))
+    assert not drawn[0] & drawn[1] and drawn[0] | drawn[1] == set(rows)
+
+
+def test_miles_data_slot_refuses_after_the_first_draw():
+    from yeto.rl.adapters.miles.buffer_rollout import apply_data_slot
+
+    source = _source(list(range(4)), False)
+    source.sample_offset = 2
+    with pytest.raises(SampleBufferRolloutError, match="before the first draw"):
+        apply_data_slot(source, DataSlot(0, 2), shuffle=False)
+    whole = _source(list(range(4)), False)
+    assert apply_data_slot(whole, DataSlot(), shuffle=False) == 4
+
+
+def test_island_env_exports_the_slot_for_a_sampler_only():
+    from yeto.rl.adapters.miles import buffer_rollout as br
+
+    env = br.island_env("sampler", store_root="/s", sampler_id="island0", shards=["island0", "island1"],
+                        data_slot="0/2")
+    assert env[br.DATA_SLOT_ENV] == "0/2"
+    with pytest.raises(ValueError, match="only a sampler"):
+        br.island_env("trainer", store_root="/s", max_policy_age=2, data_slot="0/2")
+
+
+# ------------------------------------------------------- exhausted buffer end
+def test_is_buffer_exhausted_follows_wrappers():
+    inner = SampleBufferExhausted("ended")
+    assert is_buffer_exhausted(inner)
+    try:
+        try:
+            raise inner
+        except SampleBufferExhausted as e:
+            raise RuntimeError("ray task failed") from e
+    except RuntimeError as outer:
+        assert is_buffer_exhausted(outer)
+    ray_like = RuntimeError("RayTaskError")
+    ray_like.cause = inner
+    assert is_buffer_exhausted(ray_like)
+    dual = type("SampleBufferExhausted", (RuntimeError,), {})("dual class of another process")
+    assert is_buffer_exhausted(dual)
+    assert not is_buffer_exhausted(SampleBufferRolloutError("other"))
+    assert not is_buffer_exhausted(None)
+
+
+def test_batch_reader_raises_exhausted_on_an_ended_empty_buffer():
+    from yeto.rl.adapters.miles.buffer_rollout import BatchReader
+
+    buffer = SimpleNamespace(read_cursor=5, data_ended=True, select=lambda consumer, n: [])
+    reader = BatchReader(buffer, max_policy_age=2, wait_s=0, poll_s=0)
+    with pytest.raises(SampleBufferExhausted, match="no trainable group"):
+        reader.take(3, 4, current_version=3)
+
+
+def _fake_driver(tmp_path, sync, exhaust_at):
+    from yeto.rl.engine.algorithm import AlgorithmSpec
+    from yeto.rl.engine.driver import EventTape, IslandDriver
+    from yeto.rl.engine.fake import FakeEngine, fake_capabilities
+
+    engine = FakeEngine(tensors={"base_model.model.layer.lora_A.weight": torch.zeros(1, 2)}, step_delta=1.0, capability_profile="miles-like")
+    generate = engine.rollout.generate
+
+    def gen(rollout_id, **kw):
+        if rollout_id == exhaust_at:
+            raise RuntimeError("ray task failed") from SampleBufferExhausted("ended")
+        return generate(rollout_id, **kw)
+
+    engine.rollout.generate = gen
+    return IslandDriver(learner_id=0, rollout=engine.rollout, trainer=engine.trainer,
+                        policy_state=engine.policy_state, publisher=engine.publisher,
+                        placement=engine.placement, algorithm=AlgorithmSpec(), sync=sync,
+                        events=EventTape(tmp_path / "e.jsonl", 0), capabilities=fake_capabilities("miles-like"))
+
+
+def test_driver_ends_finished_when_the_buffer_is_exhausted(tmp_path):
+    from yeto.rl.engine.bridges import LocalOnlySync
+
+    final = _fake_driver(tmp_path, LocalOnlySync(5), exhaust_at=3).run()
+    assert final.policy_version == 3
+    events = [json.loads(line) for line in (tmp_path / "e.jsonl").read_text().splitlines()]
+    names = [e["event"] for e in events]
+    assert "rl_buffer_exhausted" in names and "island_leave" not in names
+    assert next(e for e in events if e["event"] == "rl_buffer_exhausted")["rollout_id"] == 3
+
+
+def test_driver_still_fails_on_other_errors_and_on_a_strict_roster(tmp_path):
+    from yeto.rl.engine.bridges import LocalOnlySync, StrictAvgSync
+
+    assert StrictAvgSync.ends_on_data_end is False
+    sync = LocalOnlySync(5)
+    sync.ends_on_data_end = False
+    with pytest.raises(RuntimeError, match="ray task failed"):
+        _fake_driver(tmp_path, sync, exhaust_at=2).run()
+
+
+# ------------------------------------------------- rescheduled container log
+def test_container_log_follower_streams_new_containers_only():
+    from yeto.modal_runner import ContainerLogFollower
+
+    lists = iter([{"ta-a"}, {"ta-a"}, {"ta-a", "ta-b"}, {"ta-b"}])
+    streamed = []
+
+    def stream(cid):
+        streamed.append(cid)
+        yield "[modal-island 1] rank 0 container ta-b\n"
+        yield "round 2 done\nround 3 done\n"
+
+    class Collector:
+        def __init__(self):
+            self.lines = []
+
+        def feed(self, line):
+            self.lines.append(line)
+
+    collector = Collector()
+    out = io.StringIO()
+    follower = ContainerLogFollower(lambda: next(lists), stream, expected=1,
+                                    route=lambda learner: ("island1", collector) if learner == 1 else None,
+                                    out=out)
+    assert follower.poll_once() == [] and follower.baseline == {"ta-a"}
+    assert follower.poll_once() == []
+    assert follower.poll_once() == ["ta-b"]
+    follower.threads[0].join(5)
+    assert follower.poll_once() == []  # followed once
+    text = out.getvalue()
+    assert "new Modal container ta-b" in text
+    assert "[island1] round 2 done" in text and "[island1] round 3 done" in text
+    assert streamed == ["ta-b"] and collector.lines[-1] == "round 2 done\nround 3 done"
+
+
+def test_container_log_follower_only_when_new_containers_are_expected():
+    from yeto.launch.modal_islands import container_log_follower_for
+
+    ops = SimpleNamespace(list_container_ids=lambda: set(), stream_container_logs=lambda cid: iter(()))
+    cfgs = {"island0": SimpleNamespace(num_nodes=1, learner_id=0)}
+    assert container_log_follower_for(None, ops, cfgs, None, poller=object(), start=False) is None
+    assert container_log_follower_for(None, None, cfgs, None, poller=None, start=False) is None
+    follower = container_log_follower_for(None, ops, cfgs, None, poller=None, start=False)
+    assert follower is not None and follower.expected_count == 1
+    assert container_log_follower_for(None, SimpleNamespace(list_container_ids=lambda: set()), cfgs, None,
+                                      poller=None, start=False) is None
diff --git a/yeto/launch/modal_islands.py b/yeto/launch/modal_islands.py
index a7f12af6..74649a6d 100644
--- a/yeto/launch/modal_islands.py
+++ b/yeto/launch/modal_islands.py
@@ -301,6 +301,23 @@ def container_set_poller_for(args, modal_ops, modal_cfgs, on_change, *, start: b
     return poller.start() if start else poller
 
 
+def container_log_follower_for(args, modal_ops, modal_cfgs, route, *, poller, start: bool = True):
+    """The follower of rescheduled containers' logs (modal_runner.ContainerLogFollower),
+    only when a new container is expected (no failing container guard: ``poller``
+    is None) and the ops can stream one container. None otherwise."""
+    if poller is not None or modal_ops is None or not modal_cfgs:
+        return None
+    if not (callable(getattr(modal_ops, "list_container_ids", None))
+            and callable(getattr(modal_ops, "stream_container_logs", None))):
+        return None
+    from ..modal_runner import ContainerLogFollower
+
+    expected = sum(max(1, int(getattr(cfg, "num_nodes", 1) or 1)) for cfg in modal_cfgs.values())
+    follower = ContainerLogFollower(modal_ops.list_container_ids, modal_ops.stream_container_logs,
+                                    expected, route=route)
+    return follower.start() if start else follower
+
+
 def effective_recover_timeout(args) -> float:
     """The fleet controller's learner relaunch budget.
 
diff --git a/yeto/launcher.py b/yeto/launcher.py
index 0abd2f4b..6ee357ca 100644
--- a/yeto/launcher.py
+++ b/yeto/launcher.py
@@ -60,7 +60,7 @@
 )
 from .launch.modal_islands import (
     _modal_tape_run_dir, _tail_modal, _verify_modal_app_stopped, build_modal_island_config,
-    container_set_poller_for, effective_recover_timeout, pull_modal_tapes,
+    container_log_follower_for, container_set_poller_for, effective_recover_timeout, pull_modal_tapes,
     require_modal_for_gpu_exact,
 )
 from .launch.fleet import (
@@ -618,6 +618,17 @@ def container_changed() -> bool:
         if container_poller is not None:
             container_guards.append(container_poller)
 
+        def route_container(learner_id: int):
+            # the island of a rescheduled container's lines (unique learner id only:
+            # the islands of a pair all run as learner 0)
+            names = [n for n, cfg in modal_cfgs.items() if int(cfg.learner_id) == int(learner_id)]
+            if len(names) != 1:
+                return None
+            return names[0], (event_collectors.get(names[0]) if names[0] in echo_names else None)
+
+        # daemon threads; each container's log ends when the app stops
+        container_log_follower_for(args, modal_ops, modal_cfgs, route_container, poller=container_poller)
+
         from . import runs
         from .modal_runner import RoutingOps
 
diff --git a/yeto/modal_runner.py b/yeto/modal_runner.py
index b25be3c4..19ba5353 100644
--- a/yeto/modal_runner.py
+++ b/yeto/modal_runner.py
@@ -1194,6 +1194,19 @@ def stream_logs(self, call_id: str):
         for entry in modal.FunctionCall.from_id(call_id).logs.stream():
             yield getattr(entry, "message", str(entry))
 
+    def stream_container_logs(self, container_id: str):
+        """The log lines of one container (``modal container logs``; follows while it
+        runs). The function-call stream of :meth:`stream_logs` does not deliver the
+        lines of a container that Modal started after a reschedule (S25 C1)."""
+        proc = subprocess.Popen([sys.executable, "-m", "modal", "container", "logs", str(container_id)],
+                                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        try:
+            assert proc.stdout is not None
+            yield from proc.stdout
+        finally:
+            if proc.poll() is None:
+                proc.terminate()
+
 
 CONTAINER_LINE_RE = re.compile(r"\[modal-island (\d+)\] rank (\d+) container (\S+)")
 
@@ -1291,6 +1304,94 @@ def stop(self) -> None:
         self._stop.set()
 
 
+class ContainerLogFollower:
+    """Follows the logs of the Modal containers the call log streams miss (S26 E9.3).
+
+    After ``modal container stop`` (or a real reclaim) Modal runs the island's
+    input again in a new container, and the function-call log stream never
+    delivers that container's lines (S19, S25 C1), so the launcher showed only
+    the first container. Every ``interval_s`` this lists the app's running
+    containers; the first ``expected`` ids are the baseline (the call streams
+    show them); for every later id it prints one launcher warning and streams
+    that container's own log (``stream_container(id)``) on a daemon thread.
+
+    Each line is printed with a ``[<label>]`` prefix. The label is
+    ``container <id>`` until the container prints its island line
+    (``[modal-island N] rank R container ID``); then ``route(N)`` may name the
+    island and give its event collector (``(label, collector)`` or None), and
+    later lines go to that collector as well."""
+
+    def __init__(self, list_ids, stream_container, expected: int, *, route=None,
+                 interval_s: float = 30.0, out=None) -> None:
+        self.list_ids, self.stream_container = list_ids, stream_container
+        self.expected_count = max(1, int(expected))
+        self.route = route or (lambda _learner: None)
+        self.interval_s = float(interval_s)
+        self.out = out
+        self.baseline: set[str] | None = None
+        self.seen: set[str] = set()
+        self.followed: list[str] = []
+        self.threads: list[threading.Thread] = []
+        self._stop = threading.Event()
+
+    def _print(self, text: str) -> None:
+        print(text, file=self.out if self.out is not None else sys.stdout, flush=True)
+
+    def poll_once(self) -> list[str]:
+        """List once; returns the container ids it started to follow."""
+        try:
+            ids = self.list_ids()
+        except Exception as exc:  # noqa: BLE001 - a failed list is skipped
+            self._print(f"[launcher] container list failed: {exc}")
+            return []
+        if ids is None:
+            return []
+        ids = set(ids)
+        if self.baseline is None:
+            self.seen |= ids
+            if len(self.seen) >= self.expected_count:
+                self.baseline = set(self.seen)
+            return []
+        new = sorted(ids - self.baseline - set(self.followed))
+        for cid in new:
+            self.followed.append(cid)
+            self._print(f"[launcher] WARNING: new Modal container {cid} (an island was rescheduled); "
+                        "following its log")
+            thread = threading.Thread(target=self.follow, args=(cid,), daemon=True,
+                                      name=f"modal-container-log-{cid}")
+            thread.start()
+            self.threads.append(thread)
+        return new
+
+    def follow(self, cid: str) -> None:
+        label, collector = f"container {cid}", None
+        try:
+            for line in self.stream_container(cid):
+                text = str(line).rstrip("\n")
+                m = CONTAINER_LINE_RE.search(text)
+                if m and m.group(3) == cid and collector is None:
+                    routed = self.route(int(m.group(1)))
+                    if routed is not None:
+                        label, collector = routed
+                for part in text.split("\n"):
+                    self._print(f"[{label}] {part.rstrip()}")
+                if collector is not None:
+                    collector.feed(text)
+        except Exception as exc:  # noqa: BLE001 - the run goes on without this log
+            self._print(f"[launcher] log of container {cid} ended: {exc}")
+
+    def run(self) -> None:
+        while not self._stop.wait(self.interval_s):
+            self.poll_once()
+
+    def start(self) -> "ContainerLogFollower":
+        threading.Thread(target=self.run, daemon=True, name="modal-container-logs").start()
+        return self
+
+    def stop(self) -> None:
+        self._stop.set()
+
+
 class _JobStatus:
     """Duck-types sky's job status for FleetController."""
 
diff --git a/yeto/rl/adapters/miles/buffer_rollout.py b/yeto/rl/adapters/miles/buffer_rollout.py
index f0c07119..345f90db 100644
--- a/yeto/rl/adapters/miles/buffer_rollout.py
+++ b/yeto/rl/adapters/miles/buffer_rollout.py
@@ -55,6 +55,7 @@
 from yeto.rl.engine.buffer_payload import (  # noqa: F401
     PAYLOAD_SCHEMA,
     GroupWriter,
+    SampleBufferExhausted,
     SampleBufferRolloutError,
     decode_group,
     encode_group,
@@ -69,6 +70,7 @@
     lane_cursor_log,
     merges_shards,
 )
+from yeto.rl.engine.sample_roles import DataSlot
 
 SAMPLER, TRAINER, CONVERTIBLE = "sampler", "trainer", "convertible"
 ROLES = (SAMPLER, TRAINER, CONVERTIBLE)
@@ -82,6 +84,7 @@
 # S25 C1: several sampler islands on one shared directory (a Modal Volume): each
 # sampler writes its own shard, the trainer merges these shards (comma list)
 SHARDS_ENV = "YETO_SAMPLE_BUFFER_SHARDS"
+DATA_SLOT_ENV = "YETO_SAMPLE_BUFFER_DATA_SLOT"  # sampler: "index/count" of the prompt data (S26 E9.3)
 INCARNATION_ENV = "YETO_SAMPLER_INCARNATION"  # set by the sampler island before Ray starts
 # the rollout functions run in Ray workers, which inherit the raylet's environment:
 # connect_island_ray forwards these to every worker
@@ -127,13 +130,14 @@ def rollout_argv(role: str | None, *, max_policy_age: int, fully_async: bool = F
 def island_env(role: str, *, store_root: str, sampler_id: str | None = None,
                max_policy_age: int | None = None, wait_s: float | None = None,
                shard: str | None = None, shards: Sequence[str] | None = None,
-               lane: BufferLane | None = None) -> dict[str, str]:
+               lane: BufferLane | None = None, data_slot: str | None = None) -> dict[str, str]:
     """The environment the launch layer exports on the island (read in the rollout
     process). A convertible node writes like a sampler, into its own ``shard`` of
     the index, and reads like a trainer. ``shards``: the sampler shards of a
     launch with several sampler islands (a sampler writes the one named by its
     sampler id, the trainer merges them all). ``lane``: a synced trainer's
-    buffer lane."""
+    buffer lane. ``data_slot``: a sampler's slot of the prompt data
+    (``sample_roles.DataSlot``; several sampler islands draw disjoint prompts)."""
     if role not in ROLES:
         raise ValueError(f"sample buffer role {role!r}: expected one of {ROLES}")
     env = {BUFFER_ROOT_ENV: str(store_root)}
@@ -161,6 +165,10 @@ def island_env(role: str, *, store_root: str, sampler_id: str | None = None,
         if role != TRAINER:
             raise ValueError("only a trainer reads a buffer lane")
         env[LANE_ENV] = lane.env()
+    if data_slot:
+        if role != SAMPLER:
+            raise ValueError("only a sampler island draws a data slot")
+        env[DATA_SLOT_ENV] = DataSlot.parse(data_slot).env()
     return env
 
 
@@ -238,6 +246,33 @@ def renumber_group(samples: Sequence[dict[str, Any]], *, position: int,
 
 
 # ---------------------------------------------------------------------- sampler side
+def apply_data_slot(data_source: Any, slot: DataSlot, *, shuffle: bool) -> int:
+    """Keep only ``slot``'s rows in a Miles ``RolloutDataSource`` (S26 E9.3).
+
+    Called once, before the first round and before a resume seek: the dataset's
+    original rows become the slot's rows, and the current epoch's order is made
+    again from them (the same seeded shuffle, over the slot). The data cursor of
+    a later round then counts in slot rows, so a replacement incarnation with
+    the same slot seeks to the same place. Returns the slot's row count."""
+    source = getattr(data_source, "__self__", data_source)
+    dataset = getattr(source, "dataset", None)
+    if slot.whole or dataset is None:
+        return len(dataset) if dataset is not None else 0
+    origin = getattr(dataset, "origin_samples", None)
+    if origin is None:
+        raise SampleBufferRolloutError(
+            f"cannot split data source {type(source).__name__} into slot {slot.env()} "
+            "(its dataset has no origin_samples)")
+    if int(getattr(source, "sample_offset", 0) or 0) or int(getattr(source, "epoch_id", 0) or 0):
+        raise SampleBufferRolloutError("the data slot is applied before the first draw")
+    dataset.origin_samples = slot.rows(origin)
+    dataset.samples = list(dataset.origin_samples)
+    if shuffle:
+        dataset.epoch_id = None  # force the reshuffle of the current epoch over the slot
+        dataset.shuffle(int(source.epoch_id))
+    return len(dataset.samples)
+
+
 _DATA_CURSOR_FIELDS = ("sample_offset", "epoch_id", "sample_group_index", "sample_index")
 
 
@@ -395,8 +430,9 @@ def take(self, rollout_id: int, groups: int, *, current_version: int | None
             self.sleep(self.poll_s)
         end = self.buffer.read_cursor
         if not out:
-            raise SampleBufferRolloutError(f"rollout {rollout_id}: the sample buffer ended "
-                                           f"with no trainable group (position {end})")
+            raise SampleBufferExhausted(f"rollout {rollout_id}: the sample buffer ended "
+                                        f"with no trainable group (position {end}, {stale} passed "
+                                        "over as too old)")
         self._ends[rollout_id] = end
         if self.cursor_log is not None:
             self.cursor_log.append(rollout_id, [position for position, _ in out], end)
diff --git a/yeto/rl/adapters/miles/buffer_rollout_miles.py b/yeto/rl/adapters/miles/buffer_rollout_miles.py
index 2f285e2b..91f010ad 100644
--- a/yeto/rl/adapters/miles/buffer_rollout_miles.py
+++ b/yeto/rl/adapters/miles/buffer_rollout_miles.py
@@ -26,6 +26,7 @@
 from yeto.rl.engine.offpolicy_source import flat_metrics, offpolicy_source_event, payload_source_sample
 
 from .buffer_rollout import (
+    DATA_SLOT_ENV,
     DEFAULT_POLL_S,
     DEFAULT_WAIT_S,
     INCARNATION_ENV,
@@ -36,8 +37,10 @@
     TRAINER,
     WAIT_ENV,
     BatchReader,
+    DataSlot,
     SampleBufferRolloutError,
     SamplerRoundWriter,
+    apply_data_slot,
     convertible_mode,
     open_buffer,
     open_lane_log,
@@ -76,6 +79,9 @@ def __init__(self, input: RolloutFnConstructorInput) -> None:
                                           incarnation=incarnation, resume=self.resumable,
                                           reclaimed=lambda: reclaim_requested(os.environ))
         self._shuffle = bool(getattr(input.args, "rollout_shuffle", False))  # the seek re-shuffles
+        # several sampler islands draw disjoint slots of the data (S26 E9.3); before any seek
+        apply_data_slot(self.data_source, DataSlot.parse(os.environ.get(DATA_SLOT_ENV)),
+                        shuffle=self._shuffle)
 
     def _open_writer_buffer(self) -> Any:
         return open_buffer(sampler=True)
diff --git a/yeto/rl/adapters/miles/island_entry.py b/yeto/rl/adapters/miles/island_entry.py
index 48585224..47b5aa2f 100644
--- a/yeto/rl/adapters/miles/island_entry.py
+++ b/yeto/rl/adapters/miles/island_entry.py
@@ -272,7 +272,7 @@ def apply_sample_role(args, miles_args, environ=None) -> None:
         config.role, store_root=config.store, sampler_id=sampler,
         max_policy_age=int(getattr(args, "rl_max_policy_age", 0) or 0), wait_s=config.wait_s,
         shard=node, shards=getattr(args, "rl_buffer_shards", None),
-        lane=sample_roles.buffer_lane(args)))
+        lane=sample_roles.buffer_lane(args), data_slot=getattr(args, "rl_sampler_data_slot", None)))
     miles_args.yeto_rl_sample_lane = sample_roles.buffer_lane(args)  # S25 C3: None off a synced trainer
 
 
diff --git a/yeto/rl/engine/bridges.py b/yeto/rl/engine/bridges.py
index b1f955d3..f0c174dd 100644
--- a/yeto/rl/engine/bridges.py
+++ b/yeto/rl/engine/bridges.py
@@ -289,6 +289,10 @@ def record_local_round(self, stats: LocalRoundStats) -> None:
 class StrictAvgSync:
     """Strict-avg at the safe boundary: export+PUSH, wait v+1, reset-apply."""
 
+    # a strict roster has every island train every round: one island cannot end on
+    # its own when its buffer is exhausted (S26 E9.3)
+    ends_on_data_end = False
+
     def __init__(
         self,
         config: BridgeConfig,
@@ -776,6 +780,10 @@ class DualStrictAvgSync:
     ``keep_committed``; durably through the round cut, whose critic round must
     equal the actor round, 4.3)."""
 
+    # a strict roster has every island train every round: one island cannot end on
+    # its own when its buffer is exhausted (S26 E9.3)
+    ends_on_data_end = False
+
     OUTER_SYNC_KIND = "strict"
 
     def __init__(self, config: BridgeConfig, *, critic_syncer_addr: tuple[str, int],
diff --git a/yeto/rl/engine/buffer_payload.py b/yeto/rl/engine/buffer_payload.py
index 460831f3..fa566394 100644
--- a/yeto/rl/engine/buffer_payload.py
+++ b/yeto/rl/engine/buffer_payload.py
@@ -27,6 +27,30 @@ class SampleBufferRolloutError(RuntimeError):
     pass
 
 
+class SampleBufferExhausted(SampleBufferRolloutError):
+    """The samplers ended the buffer and no trainable group is left for the round
+    (S26 E9.3). The trainer's run ends normally (FINISHED) before this round; it
+    is not a failure: e.g. groups were passed over as older than max_policy_age,
+    so the data holds fewer rounds than --total-steps."""
+
+
+def is_buffer_exhausted(error: BaseException | None) -> bool:
+    """Whether ``error`` is (or wraps) :class:`SampleBufferExhausted`.
+
+    The reader raises it in the rollout process; it reaches the driver wrapped
+    (a Ray task error keeps it as ``cause`` or as a dual subclass), so the cause
+    chain is followed and the class is matched by name as well."""
+    seen: set[int] = set()
+    while error is not None and id(error) not in seen:
+        seen.add(id(error))
+        if isinstance(error, SampleBufferExhausted) or any(
+                c.__name__ == SampleBufferExhausted.__name__ for c in type(error).__mro__):
+            return True
+        cause = getattr(error, "cause", None)
+        error = cause if isinstance(cause, BaseException) else (error.__cause__ or error.__context__)
+    return False
+
+
 def _encode_value(value: Any) -> Any:
     tolist = getattr(value, "tolist", None)
     if callable(tolist) and hasattr(value, "dtype") and hasattr(value, "shape"):
diff --git a/yeto/rl/engine/driver.py b/yeto/rl/engine/driver.py
index d815a0a7..20461959 100644
--- a/yeto/rl/engine/driver.py
+++ b/yeto/rl/engine/driver.py
@@ -75,6 +75,7 @@
 from yeto.rl.elastic_client import LeaveReason
 
 from .algorithm import AlgorithmSpec
+from .buffer_payload import is_buffer_exhausted
 from .capabilities import BackendTraits, EngineCapabilities
 from .execution_profile import (
     ExecutionProfile,
@@ -1863,7 +1864,17 @@ def _run(self) -> TrainableState:
                     if self.max_rollouts is not None and rollout_id >= self.max_rollouts:
                         raise DriverError("run reached max_rollouts without a stop")
                     self.safe_point(rollout_id)
-                    boundary = self.run_round(rollout_id)
+                    try:
+                        boundary = self.run_round(rollout_id)
+                    except BaseException as error:
+                        if not (is_buffer_exhausted(error)
+                                and getattr(self.sync, "ends_on_data_end", True)):
+                            raise
+                        # S26 E9.3: the samplers ended and nothing trainable is left;
+                        # the rounds so far are trained and published: end FINISHED
+                        self.emit("rl_buffer_exhausted", rollout_id=rollout_id,
+                                  error=f"{type(error).__name__}: {error}")
+                        break
                     state = boundary.state
                     rollout_id += 1
                     self._maybe_eval(rollout_id, force=boundary.stop, defer=not boundary.stop)
diff --git a/yeto/rl/engine/engine_sampler_entry.py b/yeto/rl/engine/engine_sampler_entry.py
index f11c5307..d91694d0 100644
--- a/yeto/rl/engine/engine_sampler_entry.py
+++ b/yeto/rl/engine/engine_sampler_entry.py
@@ -24,6 +24,8 @@
 * ``prompts``: ``{"path": JSONL, "input_key", "label_key", "groups_per_round",
   "format": "text" | "chat"}`` -- round ``r`` takes the
   ``groups_per_round`` rows after row ``r * groups_per_round`` (wrapping);
+  optional ``"data_slot": "I/N"``: the sampler draws only rows ``i % N == I``
+  (``sample_roles.DataSlot``; several samplers of one run draw disjoint prompts);
   ``chat`` applies the tokenizer's chat template of ``tokenizer`` (default
   ``base_dir``) to a message list (``trust_remote_code``: optional, false);
 * ``reward``: ``"module:function"`` called as ``function(item, completion)``
@@ -62,6 +64,7 @@
 
 from .engine_sampler import EngineSamplerConfig, PromptItem, Reward, build_engine_sampler
 from .sampler_checks import PostLoadChecks
+from .sample_roles import DataSlot
 from .sampler_engine import Completion, SamplerEngine, SamplingParams
 
 PROMPT_FORMATS = ("text", "chat")
@@ -105,12 +108,20 @@ class JsonlPrompts:
     """``prompts(rollout_id)`` over a local JSONL file (module doc)."""
 
     def __init__(self, path: str | Path, *, input_key: str, label_key: str | None, groups_per_round: int,
-                 render: Callable[[Any], str] = str) -> None:
+                 render: Callable[[Any], str] = str, data_slot: str | None = None) -> None:
         self.path = Path(path)
-        self.rows = [json.loads(line) for line in self.path.read_text(encoding="utf-8").splitlines()
-                     if line.strip()]
-        if not self.rows:
+        rows = list(enumerate(json.loads(line) for line in self.path.read_text(encoding="utf-8").splitlines()
+                              if line.strip()))
+        if not rows:
             raise SamplerSpecError(f"prompts file {self.path} has no rows")
+        try:
+            self.slot = DataSlot.parse(data_slot)
+            rows = self.slot.rows(rows)
+        except ValueError as error:
+            raise SamplerSpecError(f"prompts.data_slot: {error}") from None
+        # the prompt ids keep the file's row numbers, so two slots never share one
+        self.row_numbers = [i for i, _ in rows]
+        self.rows = [row for _, row in rows]
         if int(groups_per_round) < 1:
             raise SamplerSpecError("prompts.groups_per_round must be >= 1")
         self.input_key, self.label_key = input_key, label_key
@@ -126,8 +137,8 @@ def __call__(self, rollout_id: int) -> list[PromptItem]:
         start = int(rollout_id) * self.groups_per_round
         items = []
         for offset in range(self.groups_per_round):
-            index = (start + offset) % len(self.rows)
-            row = self.rows[index]
+            index = self.row_numbers[(start + offset) % len(self.rows)]
+            row = self.rows[(start + offset) % len(self.rows)]
             if self.input_key not in row:
                 raise SamplerSpecError(f"{self.path} row {index} has no {self.input_key!r}")
             items.append(PromptItem(prompt_id=f"row{index}", prompt=self.render(row[self.input_key]),
@@ -163,7 +174,8 @@ def build_prompts(spec: Mapping[str, Any]) -> JsonlPrompts:
         render = chat_renderer(tokenizer, remote_code=bool(prompts.get("trust_remote_code", False)))
     return JsonlPrompts(_require(prompts, "path", "prompts"), input_key=str(_require(prompts, "input_key", "prompts")),
                         label_key=prompts.get("label_key"),
-                        groups_per_round=int(_require(prompts, "groups_per_round", "prompts")), render=render)
+                        groups_per_round=int(_require(prompts, "groups_per_round", "prompts")), render=render,
+                        data_slot=prompts.get("data_slot"))
 
 
 # ------------------------------------------------------------------- reward
diff --git a/yeto/rl/engine/run_flags.py b/yeto/rl/engine/run_flags.py
index b4de9148..c7f12847 100644
--- a/yeto/rl/engine/run_flags.py
+++ b/yeto/rl/engine/run_flags.py
@@ -596,6 +596,9 @@ def rl_forward_pairs(*dests: str | tuple[str, str]) -> tuple[tuple[str, str], ..
                 type=lambda text: [s for s in text.split(",") if s],
                 help="--rl-island-sample-role with several samplers: the sampler shards of the "
                 "buffer (set by the launcher); each sampler writes its own, the trainer merges them"),
+    shared_flag("--rl-sampler-data-slot", default=None, metavar="I/N",
+                help="--rl-sample-role sampler with several samplers: draw only the prompt rows "
+                "i with i %% N == I (set by the launcher; the samplers draw disjoint prompts)"),
 )
 
 _SCHEDULING = (
diff --git a/yeto/rl/engine/sample_roles.py b/yeto/rl/engine/sample_roles.py
index de65b83f..22e4c840 100644
--- a/yeto/rl/engine/sample_roles.py
+++ b/yeto/rl/engine/sample_roles.py
@@ -210,6 +210,9 @@ def island_args(args: Any, island: int, num_islands: int) -> Any:
         out.rl_sampler_node = node_name(island) if out.rl_sample_role == SAMPLER else None
         out.rl_buffer_shards = buffer_shards(args, num_islands)
         samplers = len(sampler_islands(args, num_islands))
+        # each sampler island draws its own slot of the data (S26 E9.3)
+        out.rl_sampler_data_slot = (DataSlot(sampler_islands(args, num_islands).index(island), samplers).env()
+                                    if out.rl_sample_role == SAMPLER and samplers > 1 else None)
         if out.rl_sample_role == SAMPLER and getattr(args, "rl_sampler_spot", False):
             # spot billing without the legacy --spot volume: the buffer is the sampler's
             # durable state (S25 C1)
@@ -424,4 +427,52 @@ def island_flags(args: Any) -> str:
         flags += f" --rl-sampler-node {args.rl_sampler_node}"
     if getattr(args, "rl_buffer_shards", None):
         flags += f" --rl-buffer-shards {','.join(args.rl_buffer_shards)}"
+    if getattr(args, "rl_sampler_data_slot", None):
+        flags += f" --rl-sampler-data-slot {args.rl_sampler_data_slot}"
     return flags
+
+
+# ---------------------------------------------------------------- data slots (S26 E9.3)
+@dataclass(frozen=True)
+class DataSlot:
+    """Which part of the prompt data one sampler island draws from.
+
+    Several sampler islands of one run read the same data with the same seed;
+    without a split they draw the same prompts in the same order (S25 C1: every
+    prompt sampled twice). Sampler ``index`` of ``count`` keeps the rows whose
+    original row number ``i`` has ``i % count == index``: the samplers draw
+    disjoint prompts, each in the data order (or its own seeded shuffle), and a
+    replacement incarnation of a sampler keeps its slot, so its resume cursor
+    stays valid. ``DataSlot(0, 1)`` is the whole data."""
+
+    index: int = 0
+    count: int = 1
+
+    def __post_init__(self) -> None:
+        if not (int(self.count) >= 1 and 0 <= int(self.index) < int(self.count)):
+            raise ValueError(f"data slot {self.index}/{self.count}: need 0 <= index < count")
+
+    @classmethod
+    def parse(cls, text: str | None) -> "DataSlot":
+        """``"index/count"`` (``None`` or empty: the whole data)."""
+        if not text:
+            return cls()
+        index, sep, count = str(text).partition("/")
+        if not sep:
+            raise ValueError(f"data slot {text!r}: expected 'index/count'")
+        return cls(int(index), int(count))
+
+    def env(self) -> str:
+        return f"{self.index}/{self.count}"
+
+    @property
+    def whole(self) -> bool:
+        return self.count == 1
+
+    def rows(self, rows: list) -> list:
+        """The rows of this slot, in their original order."""
+        out = list(rows[self.index::self.count])
+        if not out:
+            raise ValueError(f"data slot {self.env()} of {len(rows)} rows is empty")
+        return out
+
diff --git a/yeto/rl/stage1.py b/yeto/rl/stage1.py
index 67ed28a5..86076724 100644
--- a/yeto/rl/stage1.py
+++ b/yeto/rl/stage1.py
@@ -61,6 +61,7 @@
 from yeto.launch.node_inventory import InventoryError, Node, load_inventory
 from yeto.rl.adapters.miles.models import glm5_next
 from yeto.rl.adapters.sampler_engines.from_spec import FACTORY as ENGINE_FACTORY
+from yeto.rl.engine.sample_roles import DataSlot
 from yeto.rl.quant.schemes import release_dir_for
 
 PLAN_SCHEMA = "yeto.stage1/v1"
@@ -558,7 +559,8 @@ def expand(plan: Stage1Plan, *, hf_config: str | Path | None = None) -> Expanded
         env = {**common_env, DEVICE_FAMILY_ENV: node.device_family, **engine.env()}
         sampler_runs.append({"node": node.name, "engine_argv": engine.argv(engine.config.base_dir), "env": env,
                              "spec_path": f"{state_dir}/sampler-{node.name}.json",
-                             "spec": sampler_spec(plan, node, engine),
+                             "spec": sampler_spec(plan, node, engine, slot=DataSlot(samplers.index(node),
+                                                                                    len(samplers))),
                              "argv": ["python3", "-m", "yeto.rl.engine.engine_sampler",
                                       "--spec", f"{state_dir}/sampler-{node.name}.json"],
                              "url": f"http://{rendezvous.get(node.name)}:{engine.config.port}"})
@@ -594,8 +596,9 @@ def state_dir_of(plan: Stage1Plan) -> str:
     return f"/data/yeto/{plan.run_id}"
 
 
-def sampler_spec(plan: Stage1Plan, node: Node, engine: Any) -> dict[str, Any]:
-    """The engine sampler island's spec file (``engine_sampler_entry``)."""
+def sampler_spec(plan: Stage1Plan, node: Node, engine: Any, *, slot: DataSlot | None = None) -> dict[str, Any]:
+    """The engine sampler island's spec file (``engine_sampler_entry``). ``slot``:
+    the node's slot of the prompt data when several sampler nodes draw (S26 E9.3)."""
     sampling, task, quant = plan.section("sampling"), plan.section("task"), plan.section("quant")
     config, options = engine.config, engine.options
     server = {f.name: getattr(config, f.name) for f in dataclasses.fields(config)}
@@ -622,7 +625,8 @@ def sampler_spec(plan: Stage1Plan, node: Node, engine: Any) -> dict[str, Any]:
         "prompts": {"path": str(_get(task, "prompts_jsonl", "task")), "input_key": str(_get(task, "input_key", "task")),
                     "label_key": str(_get(task, "label_key", "task")),
                     "groups_per_round": int(task["rollout_batch_size"]),
-                    "format": str(task.get("prompt_format", "chat")), "trust_remote_code": True},
+                    "format": str(task.get("prompt_format", "chat")), "trust_remote_code": True,
+                    **({"data_slot": slot.env()} if slot is not None and not slot.whole else {})},
         "reward": str(task["reward"]), "reward_kind": "miles",
         # sampler.checks: further PostLoadChecks overrides (e.g. require_fixed_answers for a
         # cut-down rehearsal model); the expected expert count always comes from quant

From 9592db23f9c16dd90764676354bc7dceedc7acb9 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:31:45 +0000
Subject: [PATCH 03/23] Forward the Modal reclaim signal to a driver inside a
 Ray actor through the marker file

Modal signals only the container's main process (the runner); a verl
driver runs in the task runner actor, where install_preempt_handler
cannot install (not the main thread). The launcher now sets the reclaim
marker path on resumable Modal islands, so the runner writes the marker;
resume.watch_preempt_marker polls it on a daemon thread in the driver's
process and writes the same store preemption notice. Wired on verl
(rl_round_cuts_wired.preempt_marker_watch) and on Miles.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_preempt_marker.py | 137 ++++++++++++++++++++++++++++
 yeto/launcher.py                    |  15 ++-
 yeto/rl/adapters/miles/entry.py     |   4 +-
 yeto/rl/adapters/verl/round_cuts.py |  10 +-
 yeto/rl/engine/resume.py            |  49 ++++++++++
 yeto/rl/engine/sampler_resume.py    |   4 +-
 6 files changed, 213 insertions(+), 6 deletions(-)
 create mode 100644 tests/test_s26_e9_preempt_marker.py

diff --git a/tests/test_s26_e9_preempt_marker.py b/tests/test_s26_e9_preempt_marker.py
new file mode 100644
index 00000000..6f7958b9
--- /dev/null
+++ b/tests/test_s26_e9_preempt_marker.py
@@ -0,0 +1,137 @@
+"""S26 E9.1: the Modal reclaim signal reaches a driver inside a Ray actor through
+the reclaim marker file (runner writes it; a watcher thread writes the notice)."""
+
+from __future__ import annotations
+
+import io
+import json
+import signal
+import threading
+import time
+from pathlib import Path
+from types import SimpleNamespace
+
+from yeto.rl.engine.resume import PREEMPT_WATCH_THREAD, watch_preempt_marker
+from yeto.rl.engine.sampler_resume import RECLAIM_MARKER_ENV
+
+
+def _controller(tmp_path):
+    committed = []
+    return SimpleNamespace(checkpoint_store=tmp_path / "store", incarnation={"id": "abc", "index": 2},
+                           store=SimpleNamespace(commit=lambda: committed.append(1)), committed=committed)
+
+
+def _wait(cond, limit=5.0):
+    end = time.monotonic() + limit
+    while time.monotonic() < end:
+        if cond():
+            return True
+        time.sleep(0.02)
+    return False
+
+
+def test_no_marker_path_no_watcher(tmp_path):
+    assert watch_preempt_marker(_controller(tmp_path), environ={}) is None
+
+
+def test_marker_from_the_runner_becomes_the_store_notice_off_the_main_thread(tmp_path):
+    from yeto.modal_runner import _run_forwarding_to_learner
+
+    marker = tmp_path / "reclaim"
+    env = {RECLAIM_MARKER_ENV: str(marker)}
+    controller = _controller(tmp_path)
+    out = io.StringIO()
+    holder = {}
+    # the driver of a verl island runs in a Ray actor thread: start the watcher off the main thread
+    t = threading.Thread(target=lambda: holder.update(w=watch_preempt_marker(
+        controller, environ=env, poll_s=0.02, out=out)))
+    t.start()
+    t.join()
+    watcher = holder["w"]
+    assert watcher is not None and watcher._thread.name == PREEMPT_WATCH_THREAD
+    assert not watcher.fired.is_set()
+
+    # the Modal runner (container main process) gets the signal and writes the marker
+    handlers = {}
+    sig = SimpleNamespace(SIGINT=signal.SIGINT, SIGTERM=signal.SIGTERM,
+                          signal=lambda num, fn: handlers.__setitem__(num, fn))
+
+    class Proc:
+        def wait(self):
+            handlers[signal.SIGTERM](signal.SIGTERM, None)
+            return 0
+
+    assert _run_forwarding_to_learner(["true"], env, popen=lambda cmd, env: Proc(), sig=sig) == 0
+    assert marker.exists()
+    assert _wait(watcher.fired.is_set)
+    notices = tmp_path / "store" / "preempt-notices"
+    assert _wait(lambda: any(notices.glob("*.json")))
+    record = json.loads(next(notices.glob("*.json")).read_text())
+    assert record["signal"] == "SIGTERM (reclaim marker)" and record["incarnation"]["id"] == "abc"
+    assert record["saved"] is False and controller.committed
+    assert "rl_preempt_notice" in out.getvalue()
+
+
+def test_unreadable_marker_still_writes_the_notice(tmp_path):
+    marker = tmp_path / "reclaim"
+    marker.write_text("not json")
+    controller = _controller(tmp_path)
+    watcher = watch_preempt_marker(controller, environ={RECLAIM_MARKER_ENV: str(marker)}, poll_s=0.02,
+                                   out=io.StringIO())
+    notices = Path(tmp_path / "store" / "preempt-notices")
+    assert _wait(lambda: any(notices.glob("*.json")))
+    assert json.loads(next(notices.glob("*.json")).read_text())["signal"] == "unknown (reclaim marker)"
+    watcher.stop()
+
+
+def test_launcher_sets_the_marker_path_on_resumable_modal_islands_only():
+    from yeto.launcher import _resume_marker_env
+
+    resumable = SimpleNamespace(rl_resume_store="modal-volume://v/run")
+    assert _resume_marker_env(resumable, "modal") == {RECLAIM_MARKER_ENV: "/tmp/yeto-reclaim-requested"}
+    assert _resume_marker_env(resumable, "nebius") == {}
+    assert _resume_marker_env(SimpleNamespace(rl_resume_store=None), "modal") == {}
+
+
+def test_runner_turns_the_signal_into_the_marker_when_the_launcher_set_it():
+    from yeto import modal_runner
+
+    calls = []
+    orig = modal_runner._run_forwarding_to_learner
+    try:
+        modal_runner._run_forwarding_to_learner = lambda cmd, env, **kw: calls.append(env) or 0
+        assert modal_runner.run_island_script(["true"], {RECLAIM_MARKER_ENV: "/tmp/x"},
+                                              popen=lambda *a, **k: None) == 0
+    finally:
+        modal_runner._run_forwarding_to_learner = orig
+    assert calls
+
+
+def test_verl_island_in_an_actor_thread_watches_the_marker(tmp_path, monkeypatch):
+    """The verl wiring off the main thread: no signal handler, the marker watch is on."""
+    import tests.test_rl_verl_round_cuts as vrc
+    from yeto.rl.adapters.verl import round_cuts
+
+    marker = tmp_path / "reclaim"
+    monkeypatch.setenv(RECLAIM_MARKER_ENV, str(marker))
+    plan = vrc._plan(store=tmp_path / "store", state_dir=tmp_path / "state")
+    calls = []
+    real = round_cuts.wire_round_cuts
+
+    def wire(driver, resume, **kw):
+        kw["install_signals"] = True
+        out = {}
+        t = threading.Thread(target=lambda: out.update(c=real(driver, resume, **kw)))
+        t.start()
+        t.join()
+        calls.append(resume)
+        return out["c"]
+
+    monkeypatch.setattr(round_cuts, "wire_round_cuts", wire)
+    driver, _h, _c, resume, tape = vrc._island(tmp_path, plan, name="island")
+    wired = vrc._events(tape, "rl_round_cuts_wired")[0]
+    assert wired["preempt_signals"] == [] and wired["preempt_marker_watch"] is True
+    marker.write_text(json.dumps({"signal": int(signal.SIGINT)}))
+    notices = Path(resume.controller.checkpoint_store) / "preempt-notices"
+    assert _wait(lambda: any(notices.glob("*.json")))
+    assert json.loads(next(notices.glob("*.json")).read_text())["signal"] == "SIGINT (reclaim marker)"
diff --git a/yeto/launcher.py b/yeto/launcher.py
index 6ee357ca..06159de4 100644
--- a/yeto/launcher.py
+++ b/yeto/launcher.py
@@ -189,10 +189,23 @@ def _island_task(task_factory, args, spec, m, num_learners, syncer_addr, overrid
     io.apply_to_task(task, {**io.island_env(args, m, overrides),
                             **(droppable.role_env(role, spec.cloud, spec.region) if role else {}),
                             **sample_roles.island_env(iargs),
-                            **_spot_sampler_cloud_env(iargs, getattr(spec, "cloud", None))})
+                            **_spot_sampler_cloud_env(iargs, getattr(spec, "cloud", None)),
+                            **_resume_marker_env(iargs, getattr(spec, "cloud", None))})
     return task
 
 
+def _resume_marker_env(iargs, cloud: str | None) -> dict[str, str]:
+    """A resumable island on Modal (``--rl-resume-store``): the reclaim marker path
+    (S26 E9.1). Modal signals only the container's main process (the runner), so
+    the runner writes the marker and the driver's watcher thread -- in a Ray actor
+    on verl -- writes the store's preemption notice."""
+    if cloud != "modal" or not getattr(iargs, "rl_resume_store", None):
+        return {}
+    from .rl.engine.sampler_resume import DEFAULT_RECLAIM_MARKER, RECLAIM_MARKER_ENV
+
+    return {RECLAIM_MARKER_ENV: DEFAULT_RECLAIM_MARKER}
+
+
 def _spot_sampler_cloud_env(iargs, cloud: str | None) -> dict[str, str]:
     """A spot sampler island on Nebius: the VM stop reaches the sampler through the
     host unit of ``yeto.cloud.nebius_reclaim`` (Modal signals the container itself)."""
diff --git a/yeto/rl/adapters/miles/entry.py b/yeto/rl/adapters/miles/entry.py
index f05f8ac4..5bb8536d 100644
--- a/yeto/rl/adapters/miles/entry.py
+++ b/yeto/rl/adapters/miles/entry.py
@@ -881,9 +881,11 @@ def expected_policy() -> tuple[int, str]:
             elastic.controller.set_event_sink(driver.emit, journal=True)
     if resume is not None:
         sync.stop_after = resume.stop_after
-        from yeto.rl.engine.resume import install_preempt_handler
+        from yeto.rl.engine.resume import install_preempt_handler, watch_preempt_marker
 
         install_preempt_handler(resume.controller, emit=driver.emit)
+        # S26 E9.1: on Modal the signal reaches the runner, which writes the reclaim marker
+        watch_preempt_marker(resume.controller)
         _wire_round_cuts(driver, elastic=resume, miles_args=miles_args, algorithm=algorithm,
                          base_model_revision=base_model_revision)
     _wire_droppable_reclaim(sync, driver)
diff --git a/yeto/rl/adapters/verl/round_cuts.py b/yeto/rl/adapters/verl/round_cuts.py
index 735b282e..f5477ab0 100644
--- a/yeto/rl/adapters/verl/round_cuts.py
+++ b/yeto/rl/adapters/verl/round_cuts.py
@@ -15,7 +15,9 @@
 * triggers of the final cut: ``MANUAL`` (last round, our own stop),
   ``SCHEDULED`` (the head's trainer scheduler stopped us:
   ``trainer_remote`` commands, :func:`run_driver`); a preemption signal only
-  writes a marker (``install_preempt_handler``): the next launch resumes from
+  writes a marker (``install_preempt_handler`` on the main thread; in a Ray
+  actor ``watch_preempt_marker`` turns the Modal runner's reclaim marker file
+  into the same notice, S26 E9.1): the next launch resumes from
   the newest complete cut.
 
 The resume assertions of :mod:`.cut` run on this path: the restored rank digests
@@ -130,7 +132,7 @@ def wire_round_cuts(driver: Any, resume: ResumeWiring | None, *, plan: Mapping[s
     if resume is None:
         return None
     from yeto.rl.engine import round_cut
-    from yeto.rl.engine.resume import install_preempt_handler
+    from yeto.rl.engine.resume import install_preempt_handler, watch_preempt_marker
 
     controller = resume.controller
     source = round_cut.CutSource(
@@ -146,9 +148,13 @@ def wire_round_cuts(driver: Any, resume: ResumeWiring | None, *, plan: Mapping[s
     driver.sync.stop_after = resume.config.get("stop_after")
     # the handler needs the main thread (verl: the task runner actor's); [] when it is not
     signals = install_preempt_handler(controller, emit=driver.emit) if install_signals else []
+    # S26 E9.1: the signal reaches the container's main process, not this actor; the
+    # Modal runner writes the reclaim marker and this thread turns it into the notice
+    watcher = watch_preempt_marker(controller) if install_signals else None
     driver.emit("rl_round_cuts_wired", backend="verl", every=checkpoint.every,
                 keep=int(controller.keep), stop_after=driver.sync.stop_after,
                 store=str(controller.checkpoint_store), preempt_signals=list(signals),
+                preempt_marker_watch=watcher is not None,
                 restored_store=controller.restored is not None)
     return checkpoint
 
diff --git a/yeto/rl/engine/resume.py b/yeto/rl/engine/resume.py
index bfa3894e..38ee93db 100644
--- a/yeto/rl/engine/resume.py
+++ b/yeto/rl/engine/resume.py
@@ -35,6 +35,7 @@
 import logging
 import os
 import shutil
+import sys
 import time
 import uuid
 from collections.abc import Callable, Iterable, Mapping
@@ -569,6 +570,54 @@ def write_preempt_marker(store_root: Path, *, signal_name: str, incarnation: Map
     return record
 
 
+PREEMPT_WATCH_THREAD = "preempt-marker-watcher"
+
+
+def watch_preempt_marker(controller: "ResumeController", *, environ: Mapping[str, str] | None = None,
+                         poll_s: float = 0.5, out: Any = None) -> Any:
+    """S26 E9.1: the preemption marker for a driver that never gets the signal.
+
+    Modal sends SIGINT/SIGTERM to the container's main process only. A driver in
+    a Ray actor (verl: the task runner) is neither that process nor its main
+    thread, so :func:`install_preempt_handler` cannot catch it. The Modal runner
+    turns the signal into the reclaim marker file (``YETO_SPOT_RECLAIM_MARKER``,
+    set by the launcher on a resumable island); this daemon thread polls that
+    file in the actor's process and, once it appears, writes the same store
+    preemption marker as the handler (the next launch resumes from LATEST).
+    Returns the started :class:`~.sampler_resume.ReclaimWatcher`, or None when
+    the marker path is not set."""
+    from .sampler_resume import RECLAIM_MARKER_ENV, ReclaimWatcher, reclaim_marker, reclaim_requested
+
+    env = os.environ if environ is None else environ
+    if not env.get(RECLAIM_MARKER_ENV):
+        return None
+    marker = reclaim_marker(env)
+
+    def on_reclaim() -> None:
+        try:
+            signum = int(json.loads(marker.read_text(encoding="utf-8")).get("signal"))
+            name = signal_name(signum)
+        except (OSError, ValueError, TypeError, AttributeError):
+            name = "unknown"
+        record = write_preempt_marker(controller.checkpoint_store, signal_name=f"{name} (reclaim marker)",
+                                      incarnation=controller.incarnation, rollout_id=None,
+                                      store=controller.store)
+        print(f"[yeto] rl_preempt_notice {json.dumps(record, sort_keys=True)}", file=out or sys.stdout,
+              flush=True)
+
+    return ReclaimWatcher(lambda: reclaim_requested(env), on_reclaim, poll_s=poll_s,
+                          name=PREEMPT_WATCH_THREAD).start()
+
+
+def signal_name(signum: int) -> str:
+    import signal as _signal
+
+    try:
+        return _signal.Signals(int(signum)).name
+    except ValueError:
+        return f"signal {int(signum)}"
+
+
 def install_preempt_handler(controller: "ResumeController", *, emit: Callable[..., Any] | None = None,
                             signals: Iterable[str] = ("SIGTERM", "SIGINT")) -> list[str]:
     """Design 2.5: on the platform's stop signal (Modal: SIGINT/SIGTERM, then a short
diff --git a/yeto/rl/engine/sampler_resume.py b/yeto/rl/engine/sampler_resume.py
index 234b06fc..46b9718e 100644
--- a/yeto/rl/engine/sampler_resume.py
+++ b/yeto/rl/engine/sampler_resume.py
@@ -301,13 +301,13 @@ class ReclaimWatcher:
     30 s), while the island's loop may still be inside a round."""
 
     def __init__(self, reclaimed: Callable[[], bool], on_reclaim: Callable[[], Any], *,
-                 poll_s: float = 0.5) -> None:
+                 poll_s: float = 0.5, name: str = "sampler-reclaim-watcher") -> None:
         self.reclaimed = reclaimed
         self.on_reclaim = on_reclaim
         self.poll_s = float(poll_s)
         self._stop = threading.Event()
         self.fired = threading.Event()
-        self._thread = threading.Thread(target=self._run, name="sampler-reclaim-watcher", daemon=True)
+        self._thread = threading.Thread(target=self._run, name=name, daemon=True)
 
     def start(self) -> "ReclaimWatcher":
         self._thread.start()

From e20373e5c4b1f295af41b2e30771872a67ee2967 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:38:09 +0000
Subject: [PATCH 04/23] verl cuts: save only optimizer-held parameters; round
 cuts on the fully_async path

- cut.save_rank / restore_rank keep only the parameters the optimizer
  holds. verl's state dict carried a requires_grad lm_head.weight that no
  optimizer steps (865 MB per rank file on GPU T-C4).
- cut.CutPorts: the cut verbs shared by VerlTrainerGroup and
  FullyAsyncTrainerGroup (through the trainer actor's worker group).
- fully_async_cut: the data cursor counts prompts the rounds took from the
  queue; on resume the rollouter skips them in its own actor before fit
  (same continuous iterator, so the epoch order is kept); queued prompts
  at the cut are generated again. run_fully_async_island wires the resume
  store, ledger and round cuts; resume_config no longer refuses
  --rl-max-policy-age > 0. Not run on a GPU yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_rl_verl_cut.py                   |  34 ++++++
 tests/test_rl_verl_round_cuts.py            |   4 +-
 tests/test_s26_e9_verl_fully_async_cut.py   | 128 ++++++++++++++++++++
 yeto/rl/adapters/verl/cut.py                |  79 +++++++++++-
 yeto/rl/adapters/verl/fully_async_cut.py    | 100 +++++++++++++++
 yeto/rl/adapters/verl/fully_async_ports.py  |  35 +++++-
 yeto/rl/adapters/verl/fully_async_runner.py |   9 +-
 yeto/rl/adapters/verl/ports_impl.py         |  45 ++-----
 yeto/rl/adapters/verl/round_cuts.py         |   5 +-
 yeto/rl/adapters/verl/trainer.py            |  23 +++-
 10 files changed, 410 insertions(+), 52 deletions(-)
 create mode 100644 tests/test_s26_e9_verl_fully_async_cut.py
 create mode 100644 yeto/rl/adapters/verl/fully_async_cut.py

diff --git a/tests/test_rl_verl_cut.py b/tests/test_rl_verl_cut.py
index 390d4351..e15ad42b 100644
--- a/tests/test_rl_verl_cut.py
+++ b/tests/test_rl_verl_cut.py
@@ -342,3 +342,37 @@ def handles(model):
             assert torch.equal(p, q), name
             for key in ("exp_avg", "exp_avg_sq", "step"):
                 assert torch.equal(trained.optimizer.state[p][key], fresh.optimizer.state[q][key]), key
+
+
+def test_a_requires_grad_parameter_outside_the_optimizer_is_not_in_the_cut(tmp_path):
+    """S26 E9.2: verl's state dict carries ``lm_head.weight`` (requires_grad, not in the
+    optimizer: 865 MB per rank file on GPU T-C4). Only the optimizer's parameters are
+    saved; the restore needs nothing else and continues bit for bit."""
+
+    def handles(model):
+        # layer 2 keeps requires_grad but no optimizer holds it (the lm_head shape)
+        opt = torch.optim.AdamW([p for n, p in model.named_parameters() if not n.startswith("2.")], lr=1e-2)
+        return TrainHandles(model, opt, torch.optim.lr_scheduler.LambdaLR(opt, lambda s: 1.0 / (1 + s)))
+
+    trained = handles(_model())
+    assert trained.module[2].weight.requires_grad
+    for r in range(CUT):
+        _round(trained, r)
+    worker = SimpleNamespace(module=trained.module, optimizer=trained.optimizer, lr_scheduler=trained.scheduler)
+    vcut.VerlCutTrainer(lambda fn, *a: [fn(worker, *a)], optimizer_steps_per_round=K).save_cut(
+        epoch=1, context=_context(tmp_path))
+    saved = torch.load(tmp_path / "cut-v" / vcut.rank_file(0), weights_only=True)["model"]
+    assert sorted(saved) == ["0.bias", "0.weight"]
+    fresh = handles(_model())
+    fresh_worker = SimpleNamespace(module=fresh.module, optimizer=fresh.optimizer, lr_scheduler=fresh.scheduler)
+    vcut.VerlCutTrainer(lambda fn, *a: [fn(fresh_worker, *a)], optimizer_steps_per_round=K).restore_cut(
+        "cut-v", epoch=1, root=str(tmp_path), expect=_expect())
+    for r in range(CUT, TOTAL):
+        _round(trained, r)
+        _round(fresh, r)
+    for (name, p), (_, q) in zip(trained.module.named_parameters(), fresh.module.named_parameters()):
+        assert torch.equal(p, q), name
+        if p in trained.optimizer.state:
+            for key in ("exp_avg", "exp_avg_sq", "step"):
+                assert torch.equal(trained.optimizer.state[p][key], fresh.optimizer.state[q][key]), key
+    assert trained.scheduler.last_epoch == fresh.scheduler.last_epoch
diff --git a/tests/test_rl_verl_round_cuts.py b/tests/test_rl_verl_round_cuts.py
index 6653eaa6..7451e50a 100644
--- a/tests/test_rl_verl_round_cuts.py
+++ b/tests/test_rl_verl_round_cuts.py
@@ -223,8 +223,8 @@ def test_resume_config_from_flags():
         round_cuts.resume_config(_args(rl_cut_every=2))
     with pytest.raises(ValueError, match="--rl-single-island-no-sync"):
         round_cuts.resume_config(_args(rl_resume_store="/s", rl_single_island_no_sync=False))
-    with pytest.raises(ValueError, match="fully_async"):
-        round_cuts.resume_config(_args(rl_resume_store="/s", rl_max_policy_age=2))
+    # S26 E9.2: the fully_async path (--rl-max-policy-age > 0) cuts too
+    assert round_cuts.resume_config(_args(rl_resume_store="/s", rl_max_policy_age=2))["store"] == "/s"
     with pytest.raises(ValueError, match="must be >= 1"):
         round_cuts.resume_config(_args(rl_resume_store="/s", rl_cut_keep=0))
 
diff --git a/tests/test_s26_e9_verl_fully_async_cut.py b/tests/test_s26_e9_verl_fully_async_cut.py
new file mode 100644
index 00000000..37a8351e
--- /dev/null
+++ b/tests/test_s26_e9_verl_fully_async_cut.py
@@ -0,0 +1,128 @@
+"""S26 E9.2: round cuts on the verl fully_async path (CPU part).
+
+The data cursor counts prompts the rounds took from the queue; on resume the
+rollouter skips them before it starts; the trainer port cuts and restores
+through the trainer actor's worker group like the sync path."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from tests import test_rl_verl_cut as vc
+from tests import test_rl_verl_fully_async_64b as fa
+from yeto.rl.adapters.verl import fully_async_cut as fac
+
+
+class FakeRollouter:
+    """The two fields of verl's FullyAsyncRollouter the skip touches."""
+
+    def __init__(self, prompts, epochs=2):
+        self.prompts, self.epochs, self.global_steps = list(prompts), epochs, 1
+
+    def _create_continuous_iterator(self):
+        for epoch in range(self.epochs):
+            for p in self.prompts:
+                yield epoch, p
+
+
+def test_skip_draws_through_the_same_iterator_and_counts_steps():
+    r = FakeRollouter("abcd")
+    assert fac.skip_rollouter_prompts(r, 6) == {"sample_offset": 6}
+    assert list(r._create_continuous_iterator()) == [(1, "c"), (1, "d")]  # across the epoch end
+    assert r.global_steps == 7
+    with pytest.raises(RuntimeError, match="already skipped"):
+        fac.skip_rollouter_prompts(r, 1)
+    short = FakeRollouter("ab", epochs=1)
+    fac.skip_rollouter_prompts(short, 3)
+    with pytest.raises(RuntimeError, match="data ended after 2 of 3"):
+        list(short._create_continuous_iterator())
+
+
+def test_data_cursor_seek_rules():
+    seeks = []
+    cursor = fac.FullyAsyncDataCursor(lambda n: seeks.append(n) or {"sample_offset": n})
+    assert cursor.seek({"sample_offset": 0}) == {"sample_offset": 0} and seeks == []
+    assert cursor.seek({"sample_offset": 12}) == {"sample_offset": 12} and seeks == [12]
+    with pytest.raises(ValueError, match="cannot move back"):
+        cursor.seek({"sample_offset": 4})
+    with pytest.raises(ValueError, match="only"):
+        cursor.seek({"sample_offset": 12, "epoch": 0})
+    cursor.started = True
+    with pytest.raises(ValueError, match="before the rollouter starts"):
+        cursor.seek({"sample_offset": 20})
+    with pytest.raises(ValueError, match="no seek hook"):
+        fac.FullyAsyncDataCursor(None).seek({"sample_offset": 1})
+
+
+def test_optimizer_steps_per_round():
+    cfg = {"actor_rollout_ref": {"actor": {"ppo_epochs": 2, "ppo_mini_batch_size": 4}}}
+    assert fac.optimizer_steps_per_round(cfg, groups_per_round=8) == 4
+    with pytest.raises(ValueError, match="whole number"):
+        fac.optimizer_steps_per_round(cfg, groups_per_round=6)
+
+
+def test_pool_cursor_counts_every_pulled_prompt_kept_or_dropped(tmp_path):
+    queue = [fa._sample("a", 0, 0, [(0, 4)]), fa._sample("b", 0, 0, [(0, 3)]),
+             fa._sample("c", 0, 1, [(0, 2), (1, 3)]), fa._sample("d", 1, 1, [(1, 4)]),
+             fa._sample("e", 0, 0, [(0, 5)]),  # round 2: over age, dropped -- still consumed
+             fa._sample("f", 1, 2, [(1, 1), (2, 2)]), fa._sample("g", 2, 2, [(2, 6)])]
+    actor = fa.FakeTrainerActor(tmp_path / "rb", queue)
+    driver, island, _tape, _started = fa._driver(tmp_path, actor)
+    driver.run()
+    assert driver.rollout.data_cursor() == {"sample_offset": 7}
+    with pytest.raises(ValueError, match="before the rollouter starts"):
+        driver.rollout.seek_data_cursor({"sample_offset": 9})
+
+
+def test_pool_seek_before_the_start_skips_the_rollouter(tmp_path):
+    from yeto.rl.adapters.verl.fully_async_ports import FullyAsyncRolloutPool
+
+    rollouter = FakeRollouter("abcdef")
+    events = []
+    island = SimpleNamespace(required=2, rollouter_started=False,
+                             seek_rollouter=lambda n: fac.skip_rollouter_prompts(rollouter, n),
+                             emit=lambda event, **f: events.append((event, f)))
+    pool = FullyAsyncRolloutPool(island)
+    assert pool.seek_data_cursor({"sample_offset": 4}) == {"sample_offset": 4}
+    assert [p for _, p in rollouter._create_continuous_iterator()][:2] == ["e", "f"]
+    assert events == [("rl_verl_data_seek", {"data_cursor": {"sample_offset": 4}, "fully_async": True})]
+
+
+def test_trainer_group_cuts_and_restores_through_the_worker_group(tmp_path):
+    """FullyAsyncTrainerGroup's cut verbs reach the ranks through call_workers (the
+    trainer actor's yeto_call_workers) and keep the sync path's checks."""
+    from yeto.rl.adapters.verl.fully_async_ports import FullyAsyncTrainerGroup
+
+    def group(handles):
+        worker = SimpleNamespace(module=handles.module, optimizer=handles.optimizer,
+                                 lr_scheduler=handles.scheduler)
+        island = SimpleNamespace(call_workers=lambda fn, *a: [fn(worker, *a)], optimizer_steps_per_round=vc.K,
+                                 emit=lambda *a, **k: None)
+        return FullyAsyncTrainerGroup(island)
+
+    trained = vc._handles(vc._model())
+    for r in range(vc.CUT):
+        vc._round(trained, r)
+    assert group(trained).save_cut(epoch=1, context=vc._context(tmp_path)) == "cut-v"
+    fresh = vc._handles(vc._model())
+    port = group(fresh)
+    assert port.layout() == vc.vcut.layout_for(1)
+    port.restore_cut("cut-v", epoch=1, root=str(tmp_path), expect=vc._expect())
+    port.confirm_resumed_data_cursor({"sample_offset": vc.PROMPTS_PER_ROUND * vc.CUT})
+    vc._round(fresh, vc.CUT)
+    events = []
+    port._check_first_step_after_resume(vc.CUT, lambda event, **f: events.append(event))
+    assert events == ["rl_resume_check"]
+    vc._round(trained, vc.CUT)
+    vc._assert_same_train_state(trained, fresh)
+
+
+def test_trainer_group_without_cuts_refuses_to_cut():
+    from yeto.rl.adapters.verl.fully_async_ports import FullyAsyncTrainerGroup
+
+    port = FullyAsyncTrainerGroup(SimpleNamespace(call_workers=lambda fn, *a: [], optimizer_steps_per_round=None))
+    with pytest.raises(RuntimeError, match="without round cuts"):
+        port._cuts()
diff --git a/yeto/rl/adapters/verl/cut.py b/yeto/rl/adapters/verl/cut.py
index 20b6b3ae..ac5b2c53 100644
--- a/yeto/rl/adapters/verl/cut.py
+++ b/yeto/rl/adapters/verl/cut.py
@@ -10,8 +10,12 @@
 
 Rank file ``rank<NNNNN>.pt`` (``torch.save``):
 
-* ``model`` -- trainable parameters (frozen base weights are skipped: LoRA), as
-  the rank's local FSDP2 shards (``DTensor.to_local``) on CPU;
+* ``model`` -- the parameters the optimizer holds, as the rank's local FSDP2
+  shards (``DTensor.to_local``) on CPU. Frozen base weights (LoRA) and any
+  parameter outside the optimizer are skipped: verl's state dict also carries a
+  ``requires_grad`` ``lm_head.weight`` that no optimizer steps (S25 T-C4: 156 M
+  parameters, 865 MB per rank file next to ~20 M LoRA parameters); it never
+  changes, so the freshly built trainer already has it (S26 E9.2);
 * ``optim`` -- the optimizer state dict keyed by parameter name, DTensor
   entries stored as local shards; ``dtensor`` lists which entries were DTensors;
 * ``scheduler`` -- ``lr_scheduler.state_dict()``; ``rng`` -- CPU (and CUDA) RNG.
@@ -114,11 +118,24 @@ def _to_local(value: Any) -> Any:
     return value.detach().to("cpu").clone() if isinstance(value, torch.Tensor) else value
 
 
+def optimizer_names(optim_sd: Mapping[str, Any]) -> set[str]:
+    """The parameter names the optimizer holds (``get_state_dict`` writes the
+    parameter FQNs into ``param_groups[*]["params"]``)."""
+    return {str(name) for group in optim_sd.get("param_groups", []) for name in group.get("params", [])}
+
+
+def _stepped_model_state(model_sd: Mapping[str, Any], optim_sd: Mapping[str, Any]) -> dict[str, Any]:
+    """The model state dict entries of the parameters the optimizer holds."""
+    held = optimizer_names(optim_sd)
+    return {k: v for k, v in model_sd.items() if k in held}
+
+
 def _local_state(handles: TrainHandles) -> tuple[dict[str, Any], dict[str, Any], list[str]]:
-    """(model, optim, dtensor keys): the rank's local trainable state, CPU tensors only."""
+    """(model, optim, dtensor keys): the rank's local stepped state, CPU tensors only."""
     from torch.distributed.checkpoint.state_dict import get_state_dict
 
     model_sd, optim_sd = get_state_dict(handles.module, handles.optimizer, options=_state_options())
+    model_sd = _stepped_model_state(model_sd, optim_sd)
     dtensors = sorted(f"model/{k}" for k, v in model_sd.items() if _is_dtensor(v))
     model = {k: _to_local(v) for k, v in model_sd.items()}
     state = {}
@@ -261,7 +278,8 @@ def restore_rank(handles: TrainHandles, *, directory: str, files: Sequence[Mappi
     if saved.get("schema") != RANK_FILE_SCHEMA or saved.get("cut_id") != cut_id or saved.get("rank") != rank:
         raise CutError(f"rank {rank}: {entry.path} is not this rank's file of cut {cut_id!r}")
 
-    template, _ = get_state_dict(handles.module, handles.optimizer, options=_state_options())
+    template, template_optim = get_state_dict(handles.module, handles.optimizer, options=_state_options())
+    template = _stepped_model_state(template, template_optim)
     if set(template) != set(saved["model"]):
         raise CutError(f"rank {rank}: trainable parameters differ from the cut: "
                        f"{sorted(set(template) ^ set(saved['model']))[:4]}")
@@ -478,3 +496,56 @@ def check_first_step(self, rounds: int = 1) -> None:
         now = ResumeManifest(saved.global_step + rounds, saved.data_watermark, saved.scheduler_increment,
                              _rank_states(results))
         require_first_step(saved, now, steps=rounds, optimizer_steps=rounds * self.optimizer_steps_per_round)
+
+
+class CutPorts:
+    """The cut verbs of a verl trainer port, over :class:`VerlCutTrainer` (shared by
+    the sync path's ``VerlTrainerGroup`` and the fully_async ``FullyAsyncTrainerGroup``).
+
+    The port gives ``_cut_calls()`` (``call_workers``: ``fn(worker, *args)`` on
+    every FSDP rank) and ``_optimizer_steps_per_round()``; it calls
+    :meth:`_check_first_step_after_resume` after a train step."""
+
+    _cut_trainer: VerlCutTrainer | None = None
+
+    def _cut_calls(self) -> Callable[..., list]:
+        raise NotImplementedError
+
+    def _optimizer_steps_per_round(self) -> int:
+        raise NotImplementedError
+
+    def _cuts(self) -> VerlCutTrainer:
+        if self._cut_trainer is None:
+            self._cut_trainer = VerlCutTrainer(self._cut_calls(),
+                                               optimizer_steps_per_round=self._optimizer_steps_per_round())
+        return self._cut_trainer
+
+    def layout(self) -> dict[str, int]:
+        return self.actual_layout()
+
+    def actual_layout(self) -> dict[str, int]:
+        return common_layout(self._cut_calls()(remote_rank_layout))
+
+    def save_cut(self, *, epoch: int, context: CutContext) -> str:
+        return self._cuts().save_cut(epoch=epoch, context=context)
+
+    def restore_cut(self, cut_id: str, *, epoch: int, root: str, expect: RestoreExpectation,
+                    shared_filesystem: bool = True) -> CutManifest:
+        return self._cuts().restore_cut(cut_id, epoch=epoch, root=root, expect=expect,
+                                        shared_filesystem=shared_filesystem)
+
+    def confirm_resumed_data_cursor(self, cursor: Mapping[str, int]) -> None:
+        self._cuts().confirm_resumed_data_cursor(cursor)
+
+    def reshard_problems(self, plan: Any, **_: object) -> list[str]:
+        return ["verl FSDP2 cuts restore at the same world size only (no DP change)"]
+
+    def _check_first_step_after_resume(self, rollout_id: int, emit: Callable[..., Any]) -> None:
+        """After a train step with a gradient: the first-step check of a pending restore."""
+        if self._cut_trainer is None:
+            return
+        pending = self._cut_trainer.resume_reference is not None
+        self._cut_trainer.check_first_step(1)  # no-op unless a restore is pending; raises on a problem
+        if pending:
+            emit("rl_resume_check", rollout_id=rollout_id, check="first_step", ok=True,
+                 optimizer_steps=self._cut_trainer.optimizer_steps_per_round)
diff --git a/yeto/rl/adapters/verl/fully_async_cut.py b/yeto/rl/adapters/verl/fully_async_cut.py
new file mode 100644
index 00000000..3e094b67
--- /dev/null
+++ b/yeto/rl/adapters/verl/fully_async_cut.py
@@ -0,0 +1,100 @@
+"""Round cuts on the verl fully_async path (S26 E9.2; S25 C4 refused them).
+
+The cut itself is the sync path's (:mod:`.cut`: one yeto file per FSDP rank of
+the trainer actor's worker group, reached through ``yeto_call_workers``). What
+differs is the data cursor: verl's ``FullyAsyncRollouter`` draws prompts on its
+own, ahead of the trainer (the MessageQueue and the requests in flight hold
+prompts no round has consumed yet). At a cut those prompts are not saved:
+
+* the cursor is ``{"sample_offset": prompts the trainer took from the queue}``
+  (kept or discarded by the policy-age gate), counted by
+  :class:`FullyAsyncDataCursor`, never the rollouter's own draw count;
+* on resume, before the rollouter's generation loop starts, the rollouter skips
+  that many prompts of its dataloader (:func:`skip_rollouter_prompts`, run in
+  the rollouter actor through ``__ray_call__``): the skip draws through the same
+  continuous iterator, so the epoch/shuffle order of an uninterrupted run is
+  kept; prompts that were queued or in flight at the cut are generated again by
+  the restored policy (each prompt is trained at most once; one that was queued
+  at the cut is generated twice in total).
+
+Pure Python; the rollouter is duck-typed (``_create_continuous_iterator``,
+``global_steps``), so the unit tests use a fake. Not yet run on a GPU.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator, Mapping
+from typing import Any
+
+CURSOR_KEY = "sample_offset"
+
+
+def skip_rollouter_prompts(rollouter: Any, prompts: int) -> dict[str, int]:
+    """Runs INSIDE the rollouter actor before its ``fit``: its continuous iterator
+    starts ``prompts`` prompts in (drawn and discarded), and its step counter
+    (``global_steps``, one per fed prompt; the feed stops at
+    ``total_rollout_steps``) counts them as fed."""
+    prompts = int(prompts)
+    if prompts < 0:
+        raise ValueError(f"cannot skip {prompts} prompts")
+    if getattr(rollouter, "_yeto_skipped", None) is not None:
+        raise RuntimeError("the rollouter's prompts were already skipped once")
+    original: Callable[[], Iterator[Any]] = rollouter._create_continuous_iterator
+
+    def skipped() -> Iterator[Any]:
+        iterator = original()
+        for drawn in range(prompts):
+            if next(iterator, None) is None:
+                raise RuntimeError(f"the rollouter's data ended after {drawn} of {prompts} skipped prompts")
+        yield from iterator
+
+    rollouter._create_continuous_iterator = skipped
+    rollouter._yeto_skipped = prompts
+    rollouter.global_steps = int(rollouter.global_steps) + prompts
+    return {CURSOR_KEY: prompts}
+
+
+class FullyAsyncDataCursor:
+    """The fully_async pool's data cursor (module doc): prompts consumed by rounds."""
+
+    def __init__(self, seek_rollouter: Callable[[int], Mapping[str, int]] | None) -> None:
+        self.seek_rollouter = seek_rollouter
+        self.consumed = 0
+        self.started = False
+
+    def cursor(self) -> dict[str, int]:
+        return {CURSOR_KEY: int(self.consumed)}
+
+    def consume(self, prompts: int) -> None:
+        self.consumed += int(prompts)
+
+    def seek(self, cursor: Mapping[str, int]) -> dict[str, int]:
+        if set(cursor) != {CURSOR_KEY}:
+            raise ValueError(f"verl fully_async data cursor is {{{CURSOR_KEY!r}}} only, got {dict(cursor)}")
+        target = int(cursor[CURSOR_KEY])
+        if self.started:
+            raise ValueError("the fully_async data cursor moves only before the rollouter starts")
+        if target < self.consumed:
+            raise ValueError(f"verl fully_async data cursor cannot move back from {self.consumed} to {target}")
+        if target == self.consumed:
+            return self.cursor()
+        if self.seek_rollouter is None:
+            raise ValueError("this fully_async island cannot move its rollouter's data (no seek hook)")
+        landed = int(self.seek_rollouter(target - self.consumed)[CURSOR_KEY])
+        self.consumed += landed
+        return self.cursor()
+
+
+def optimizer_steps_per_round(config: Mapping[str, Any], *, groups_per_round: int) -> int:
+    """Optimizer steps of one fully_async ``update_actor`` (the resume first-step
+    check): ``ppo_epochs`` x (prompts per round / ``ppo_mini_batch_size``). verl's
+    ``data.train_batch_size`` is 0 on this path, so the round size is yeto's
+    ``groups_per_round``. Not yet checked against a live run (the first resumed
+    round refuses a wrong value)."""
+    actor = ((config.get("actor_rollout_ref") or {}).get("actor") or {})
+    epochs = int(actor.get("ppo_epochs", 1) or 1)
+    mini = int(actor.get("ppo_mini_batch_size") or 0)
+    if mini <= 0 or int(groups_per_round) % mini:
+        raise ValueError(f"groups_per_round {groups_per_round} is not a whole number of "
+                         f"ppo_mini_batch_size {mini}")
+    return epochs * (int(groups_per_round) // mini)
diff --git a/yeto/rl/adapters/verl/fully_async_ports.py b/yeto/rl/adapters/verl/fully_async_ports.py
index 061fb920..1526d389 100644
--- a/yeto/rl/adapters/verl/fully_async_ports.py
+++ b/yeto/rl/adapters/verl/fully_async_ports.py
@@ -38,6 +38,8 @@
 from yeto.rl.engine.ports import PlacementDescription, PublicationResult, RolloutBatchHandle
 
 from . import publish as pub
+from .cut import CutPorts
+from .fully_async_cut import FullyAsyncDataCursor
 from .fully_async_round import (DISCARD_MECHANISM, FULLY_ASYNC_PLACEMENT, RoundCollector,
                                 SampleMeta, group_metadata)
 from .fully_async_translate import VersionMap
@@ -56,8 +58,13 @@ class FullyAsyncIsland:
     def __init__(self, call: Callable[..., Any], *, learner_id: int, limit: int, required: int,
                  out_dir: str, readback_dir: str, emit=None, start_rollouter=None,
                  base_model_revision: str = "", lora_config_hash: str = "", layout_hash: str = "",
-                 expected_specs=()):
+                 expected_specs=(), seek_rollouter=None, optimizer_steps_per_round: int | None = None):
+        """``seek_rollouter(prompts)``: skip that many prompts of the rollouter's data
+        before it starts (``fully_async_cut.skip_rollouter_prompts``; round cuts, S26
+        E9.2). ``optimizer_steps_per_round``: the resume first-step check."""
         self.call = call
+        self.seek_rollouter = seek_rollouter
+        self.optimizer_steps_per_round = optimizer_steps_per_round
         self.base_model_revision = base_model_revision
         self.lora_config_hash = lora_config_hash
         self.layout_hash = layout_hash
@@ -96,6 +103,17 @@ class FullyAsyncRolloutPool:
     def __init__(self, island: FullyAsyncIsland, *, max_pulls_factor: int = 8):
         self.island = island
         self.max_pulls = max_pulls_factor * island.required
+        self._cursor = FullyAsyncDataCursor(island.seek_rollouter)
+
+    def data_cursor(self) -> dict[str, int]:
+        """Prompts the rounds took from the queue (kept or discarded; .fully_async_cut)."""
+        return self._cursor.cursor()
+
+    def seek_data_cursor(self, cursor) -> dict[str, int]:
+        self._cursor.started = self.island.rollouter_started
+        landed = self._cursor.seek(cursor)
+        self.island.emit("rl_verl_data_seek", data_cursor=landed, fully_async=True)
+        return landed
 
     def generate(self, rollout_id: int, *, expected_policy_version: str | None = None) -> RolloutBatchHandle:
         isl = self.island
@@ -116,6 +134,7 @@ def generate(self, rollout_id: int, *, expected_policy_version: str | None = Non
             if meta is None:
                 raise RuntimeError(f"rollout {rollout_id}: rollouter ended the queue")
             pulled += 1
+            self._cursor.consume(1)
             keep = collector.offer(SampleMeta(**meta))
             isl.call("yeto_keep_last" if keep else "yeto_drop_last")
         queue = isl.call("yeto_assemble")
@@ -154,12 +173,22 @@ def members(self) -> frozenset[str]:
         return frozenset({MEMBER})
 
 
-class FullyAsyncTrainerGroup:
+class FullyAsyncTrainerGroup(CutPorts):
     publish_offloaded = False
 
     def __init__(self, island: FullyAsyncIsland):
         self.island = island
         self._metrics = None
+        self._cut_trainer = None
+
+    # ---- cut verbs (S26 E9.2; .cut.CutPorts over the trainer actor's worker group) ----
+    def _cut_calls(self):
+        return self.island.call_workers
+
+    def _optimizer_steps_per_round(self) -> int:
+        if self.island.optimizer_steps_per_round is None:
+            raise RuntimeError("this fully_async island was built without round cuts")
+        return int(self.island.optimizer_steps_per_round)
 
     def onload(self) -> None:
         return None
@@ -197,6 +226,8 @@ def metric(*suffixes):
             grad_norm=float("nan") if grad_norm is None else grad_norm, loss=metric("pg_loss"),
             pg_loss=metric("pg_loss"), lr=lr, clip_fraction=metric("pg_clipfrac"),
             train_step=batch.rollout_id, applied_lrs=None if lr is None else (lr,))
+        if grad_norm is not None:
+            self._check_first_step_after_resume(batch.rollout_id, isl.emit)
         ids = tuple(s for g in batch.groups for s in g.sample_ids)
         return LocalStepReceipt(
             algorithm="grpo", learner_id=isl.learner_id, learner_generation=0,
diff --git a/yeto/rl/adapters/verl/fully_async_runner.py b/yeto/rl/adapters/verl/fully_async_runner.py
index 900ccf6d..677e62ac 100644
--- a/yeto/rl/adapters/verl/fully_async_runner.py
+++ b/yeto/rl/adapters/verl/fully_async_runner.py
@@ -222,6 +222,12 @@ def run(self, config, plan: dict):
         def start_rollouter():
             state["future"] = rollouter.fit.remote()
 
+        def seek_rollouter(prompts: int):
+            # S26 E9.2: before fit, in the rollouter actor (fully_async_cut)
+            from .fully_async_cut import skip_rollouter_prompts
+
+            return ray.get(rollouter.__ray_call__.remote(skip_rollouter_prompts, int(prompts)))
+
         def call(name, *args, timeout=None):
             # timeout (s): S19 async5 hung 33 min in a push whose vLLM side had died;
             # a call that does not return in time raises TimeoutError.
@@ -240,7 +246,8 @@ def call(name, *args, timeout=None):
 
         try:
             return run_fully_async_island(call, start_rollouter, plan,
-                                          OmegaConf.to_container(config, resolve=True))
+                                          OmegaConf.to_container(config, resolve=True),
+                                          seek_rollouter=seek_rollouter)
         finally:
             if state["future"] is not None:
                 ray.cancel(state["future"])
diff --git a/yeto/rl/adapters/verl/ports_impl.py b/yeto/rl/adapters/verl/ports_impl.py
index 4952a73c..0bde7680 100644
--- a/yeto/rl/adapters/verl/ports_impl.py
+++ b/yeto/rl/adapters/verl/ports_impl.py
@@ -39,6 +39,7 @@
 from yeto.rl.engine.trainable_state import TrainableState
 
 from . import publish as pub
+from .cut import CutPorts
 from .param_names import train_to_canonical
 
 MEMBER = "vllm-0"
@@ -268,7 +269,7 @@ def members(self) -> frozenset[str]:
         return frozenset({MEMBER})
 
 
-class VerlTrainerGroup:
+class VerlTrainerGroup(CutPorts):
     publish_offloaded = False
 
     def __init__(self, island: VerlIsland):
@@ -276,36 +277,14 @@ def __init__(self, island: VerlIsland):
         self._metrics = None
         self._cut_trainer = None
 
-    # ---- cut verbs (S25 N7.6; .cut) ----
-    def _cuts(self):
-        if self._cut_trainer is None:
-            from .cut import VerlCutTrainer, optimizer_steps_per_round
+    # ---- cut verbs (S25 N7.6; .cut.CutPorts) ----
+    def _cut_calls(self):
+        return self.island.call_workers
 
-            self._cut_trainer = VerlCutTrainer(
-                self.island.call_workers,
-                optimizer_steps_per_round=optimizer_steps_per_round(self.island.trainer.config))
-        return self._cut_trainer
+    def _optimizer_steps_per_round(self) -> int:
+        from .cut import optimizer_steps_per_round
 
-    def layout(self) -> dict[str, int]:
-        return self.actual_layout()
-
-    def actual_layout(self) -> dict[str, int]:
-        from .cut import common_layout, remote_rank_layout
-
-        return common_layout(self.island.call_workers(remote_rank_layout))
-
-    def save_cut(self, *, epoch: int, context) -> str:
-        return self._cuts().save_cut(epoch=epoch, context=context)
-
-    def restore_cut(self, cut_id: str, *, epoch: int, root: str, expect, shared_filesystem: bool = True):
-        return self._cuts().restore_cut(cut_id, epoch=epoch, root=root, expect=expect,
-                                        shared_filesystem=shared_filesystem)
-
-    def confirm_resumed_data_cursor(self, cursor) -> None:
-        self._cuts().confirm_resumed_data_cursor(cursor)
-
-    def reshard_problems(self, plan, **_: object) -> list[str]:
-        return ["verl FSDP2 cuts restore at the same world size only (no DP change)"]
+        return optimizer_steps_per_round(self.island.trainer.config)
 
     def onload(self) -> None:
         return None
@@ -356,12 +335,8 @@ def train_step(self, batch: RolloutBatchHandle) -> LocalStepReceipt:
             train_step=batch.rollout_id,
             applied_lrs=None if lr is None else (lr,),
         )
-        if grad_norm is not None and self._cut_trainer is not None:
-            pending = self._cut_trainer.resume_reference is not None
-            self._cut_trainer.check_first_step(1)  # no-op unless a restore is pending; raises on a problem
-            if pending:
-                isl.emit("rl_resume_check", rollout_id=batch.rollout_id, check="first_step", ok=True,
-                         optimizer_steps=self._cut_trainer.optimizer_steps_per_round)
+        if grad_norm is not None:
+            self._check_first_step_after_resume(batch.rollout_id, isl.emit)
         ids = tuple(s for g in batch.groups for s in g.sample_ids)
         return LocalStepReceipt(
             algorithm="grpo", learner_id=isl.learner_id, learner_generation=0,
diff --git a/yeto/rl/adapters/verl/round_cuts.py b/yeto/rl/adapters/verl/round_cuts.py
index f5477ab0..77f27e2a 100644
--- a/yeto/rl/adapters/verl/round_cuts.py
+++ b/yeto/rl/adapters/verl/round_cuts.py
@@ -73,9 +73,8 @@ def resume_config(args: Any) -> dict[str, Any] | None:
     if not getattr(args, "rl_single_island_no_sync", False):
         raise ValueError("--rl-resume-store needs --rl-single-island-no-sync (a synced island "
                          "resumes from the syncer)")
-    if int(getattr(args, "rl_max_policy_age", 0) or 0):
-        raise ValueError("--rl-resume-store is not wired for the verl fully_async path "
-                         "(--rl-max-policy-age > 0)")
+    # --rl-max-policy-age > 0 (the fully_async path) cuts too since S26 E9.2
+    # (.fully_async_cut: the rollouter skips the consumed prompts on resume)
     return {
         "store": str(store),
         "state_dir": str(getattr(args, "rl_resume_state_dir", None) or DEFAULT_STATE_DIR),
diff --git a/yeto/rl/adapters/verl/trainer.py b/yeto/rl/adapters/verl/trainer.py
index 6be18c9e..a6247fa4 100644
--- a/yeto/rl/adapters/verl/trainer.py
+++ b/yeto/rl/adapters/verl/trainer.py
@@ -280,7 +280,8 @@ def run_island(trainer, agent_loop_manager, plan: dict, cfg: dict) -> dict:
     return result
 
 
-def run_fully_async_island(call, start_rollouter, plan: dict, cfg: dict, *, buffer_ports=None) -> dict:
+def run_fully_async_island(call, start_rollouter, plan: dict, cfg: dict, *, buffer_ports=None,
+                           seek_rollouter=None) -> dict:
     """agentic-rollout-utilization 6.4b: the yeto driver over the fully_async ports.
 
     ``call(method, *args)`` reaches the trainer actor; ``start_rollouter`` starts the
@@ -288,7 +289,10 @@ def run_fully_async_island(call, start_rollouter, plan: dict, cfg: dict, *, buff
 
     ``buffer_ports(island)``: a buffer trainer (S25 C2, ``buffer_ports.install_buffer_ports``
     bound to the run's buffer and release store) returns ``(rollout, publisher,
-    placement)``; the trainer port and the policy state stay the fully_async ones."""
+    placement)``; the trainer port and the policy state stay the fully_async ones.
+
+    ``seek_rollouter(prompts)``: skips prompts of the rollouter's data before it
+    starts (round cuts with ``--rl-resume-store``, S26 E9.2; :mod:`.fully_async_cut`)."""
     from yeto.rl.core import canonical_layout_hash, canonical_lora_config_hash
     from yeto.rl.engine.algorithm import AlgorithmSpec
     from yeto.rl.engine.driver import EventTape, IslandDriver
@@ -298,6 +302,8 @@ def run_fully_async_island(call, start_rollouter, plan: dict, cfg: dict, *, buff
     from .entry import verl_capabilities
     from .fully_async_ports import (FullyAsyncIsland, FullyAsyncPlacement, FullyAsyncPublisher,
                                     FullyAsyncRolloutPool, FullyAsyncTrainerGroup)
+    from . import round_cuts
+    from .fully_async_cut import optimizer_steps_per_round
     from .fully_async_round import execution_profile_for
     from .identity import backend_identity
     from .ports_impl import VerlPolicyState
@@ -316,7 +322,9 @@ def run_fully_async_island(call, start_rollouter, plan: dict, cfg: dict, *, buff
         out_dir=plan["out_dir"], readback_dir=os.environ.get("YETO_VERL_READBACK_DIR", plan["out_dir"]),
         emit=lambda event, **f: tape.append({"event": event, **f}), start_rollouter=start_rollouter,
         base_model_revision=plan["model_revision"], lora_config_hash=lora_hash,
-        layout_hash=layout_hash, expected_specs=specs)
+        layout_hash=layout_hash, expected_specs=specs, seek_rollouter=seek_rollouter,
+        optimizer_steps_per_round=(optimizer_steps_per_round(cfg, groups_per_round=int(plan["groups_per_round"]))
+                                   if plan.get("resume") else None))
     call("yeto_configure", float(plan.get("tis_upper", 2.0)), list(plan["thresholds_key"]))
     from yeto.hw.catalog import runtime_versions
 
@@ -339,14 +347,19 @@ def run_fully_async_island(call, start_rollouter, plan: dict, cfg: dict, *, buff
                                          FullyAsyncPlacement())
     else:
         rollout, publisher, placement = buffer_ports(island)
+    if buffer_ports is not None and plan.get("resume"):
+        raise ValueError("round cuts are not wired for a verl buffer trainer")
+    # S26 E9.2: round cuts as on the sync path; restored before the driver is built
+    resume = round_cuts.resume_wiring_for(plan, runtime_fingerprint=_fingerprint(cfg))
     driver = IslandDriver(
         learner_id=learner_id, rollout=rollout, trainer=FullyAsyncTrainerGroup(island),
         policy_state=VerlPolicyState(island), publisher=publisher, placement=placement,
         capabilities=verl_capabilities(_fingerprint(cfg), fully_async_limit=limit), algorithm=spec,
-        sync=sync, events=tape, profile=profile)
+        sync=sync, events=tape, profile=profile, ledger=None if resume is None else resume.ledger)
     if buffer_ports is not None:
         publisher.bind(driver)  # synced buffer trainers release the driver's merged version
-    state = driver.run()
+    round_cuts.wire_round_cuts(driver, resume, plan=plan, algorithm=spec)
+    state = round_cuts.run_driver(driver, resume)
     result = {"learner_id": learner_id, "rounds_completed": driver.rounds_completed,
               "final_policy_version": state.policy_version,
               "final_policy_tensor_hash": state.policy_tensor_hash(),

From e7cae5d0cf4da77ce4af9880f0a863a79768c52e Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:44:42 +0000
Subject: [PATCH 05/23] Set the reclaim marker path from --rl-checkpoint-store
 (the launcher's resume store), not the island flag

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_preempt_marker.py | 7 +++++--
 yeto/launcher.py                    | 5 +++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/tests/test_s26_e9_preempt_marker.py b/tests/test_s26_e9_preempt_marker.py
index 6f7958b9..b0f53e24 100644
--- a/tests/test_s26_e9_preempt_marker.py
+++ b/tests/test_s26_e9_preempt_marker.py
@@ -87,10 +87,13 @@ def test_unreadable_marker_still_writes_the_notice(tmp_path):
 def test_launcher_sets_the_marker_path_on_resumable_modal_islands_only():
     from yeto.launcher import _resume_marker_env
 
-    resumable = SimpleNamespace(rl_resume_store="modal-volume://v/run")
+    resumable = SimpleNamespace(rl_checkpoint_store="modal-volume://v/run", rl_elastic=False)
     assert _resume_marker_env(resumable, "modal") == {RECLAIM_MARKER_ENV: "/tmp/yeto-reclaim-requested"}
     assert _resume_marker_env(resumable, "nebius") == {}
-    assert _resume_marker_env(SimpleNamespace(rl_resume_store=None), "modal") == {}
+    assert _resume_marker_env(SimpleNamespace(rl_checkpoint_store=None), "modal") == {}
+    # --rl-elastic keeps its own checkpoint store and LEAVE path
+    assert _resume_marker_env(SimpleNamespace(rl_checkpoint_store="modal-volume://v/run", rl_elastic=True),
+                              "modal") == {}
 
 
 def test_runner_turns_the_signal_into_the_marker_when_the_launcher_set_it():
diff --git a/yeto/launcher.py b/yeto/launcher.py
index 06159de4..989cbbc7 100644
--- a/yeto/launcher.py
+++ b/yeto/launcher.py
@@ -195,11 +195,12 @@ def _island_task(task_factory, args, spec, m, num_learners, syncer_addr, overrid
 
 
 def _resume_marker_env(iargs, cloud: str | None) -> dict[str, str]:
-    """A resumable island on Modal (``--rl-resume-store``): the reclaim marker path
+    """A resumable island on Modal (``--rl-checkpoint-store`` without
+    ``--rl-elastic``: the island's ``--rl-resume-store``): the reclaim marker path
     (S26 E9.1). Modal signals only the container's main process (the runner), so
     the runner writes the marker and the driver's watcher thread -- in a Ray actor
     on verl -- writes the store's preemption notice."""
-    if cloud != "modal" or not getattr(iargs, "rl_resume_store", None):
+    if cloud != "modal" or not getattr(iargs, "rl_checkpoint_store", None) or getattr(iargs, "rl_elastic", False):
         return {}
     from .rl.engine.sampler_resume import DEFAULT_RECLAIM_MARKER, RECLAIM_MARKER_ENV
 

From fa7413f51a616e4cbbbefc87d0bb683565be57f1 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:48:26 +0000
Subject: [PATCH 06/23] One verl launch starts its sampler islands: the verl
 island entry runs the engine sampler for role sampler

- verl island_entry accepts the pair flags the launcher forwards
  (--rl-sampler-node, --rl-buffer-shards, --rl-sampler-data-slot, backlog
  and throttle) and, for --rl-sample-role sampler, runs
  adapters.verl.sampler_entry: an engine sampler spec on the image's vLLM
  (vllm-server) over the run store, prompts rendered with the chat template.
- engine sampler spec: optional buffer_shards (several samplers on one
  shared directory write their own shard); open_trainer_buffer merges the
  named shards; the verl buffer trainer passes them.
- Dry-run tests through the real launcher task builder: a verl pair, two
  samplers (shards, disjoint data slots, split rounds), and synced verl
  trainers with a separate sampler launch over the same store.
  Not run on a GPU yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_rl_verl_buffer_trainer.py          |   4 +-
 tests/test_s26_e9_verl_pair_launch.py         | 169 ++++++++++++++++++
 .../rl/adapters/verl/buffer_trainer_runner.py |   3 +-
 yeto/rl/adapters/verl/island_entry.py         |  25 ++-
 yeto/rl/adapters/verl/sampler_entry.py        | 151 ++++++++++++++++
 yeto/rl/engine/engine_sampler_entry.py        |  10 +-
 yeto/rl/engine/sample_buffer.py               |  12 +-
 7 files changed, 363 insertions(+), 11 deletions(-)
 create mode 100644 tests/test_s26_e9_verl_pair_launch.py
 create mode 100644 yeto/rl/adapters/verl/sampler_entry.py

diff --git a/tests/test_rl_verl_buffer_trainer.py b/tests/test_rl_verl_buffer_trainer.py
index 58dea824..1b322d6c 100644
--- a/tests/test_rl_verl_buffer_trainer.py
+++ b/tests/test_rl_verl_buffer_trainer.py
@@ -353,8 +353,10 @@ def test_island_entry_plans_a_buffer_trainer_and_refuses_other_roles():
                                                 "--rl-single-island-no-sync",
                                                 "--rl-max-policy-age", "1", "--rl-sample-wait-s", "60"))
     assert section == {"store": "/s", "wait_s": 60.0, "lane": None}
+    # S26 E9.4: a sampler island runs the engine sampler (no buffer section); other roles stop
+    assert sample_buffer_section(_entry_args("--rl-sample-role", "sampler", "--rl-resume-store", "/s")) is None
     with pytest.raises(SystemExit, match="engine sampler"):
-        sample_buffer_section(_entry_args("--rl-sample-role", "sampler", "--rl-resume-store", "/s"))
+        sample_buffer_section(_entry_args("--rl-sample-role", "convertible", "--rl-resume-store", "/s"))
     with pytest.raises(SystemExit, match="max-policy-age"):
         sample_buffer_section(_entry_args("--rl-sample-role", "trainer", "--rl-resume-store", "/s"))
 
diff --git a/tests/test_s26_e9_verl_pair_launch.py b/tests/test_s26_e9_verl_pair_launch.py
new file mode 100644
index 00000000..8480fa0d
--- /dev/null
+++ b/tests/test_s26_e9_verl_pair_launch.py
@@ -0,0 +1,169 @@
+"""S26 E9.4: one launch starts a verl trainer island and its sampler islands (dry run).
+
+``yeto launch --rl-backend verl --rl-island-sample-role ...`` builds every island
+with the verl island entry; a sampler island runs the engine sampler on the verl
+image's vLLM (:mod:`yeto.rl.adapters.verl.sampler_entry`). No cloud, no GPU."""
+
+from __future__ import annotations
+
+import shlex
+import sys
+import types
+
+import pytest
+
+from tests.test_rl_engine_selection import _cli
+from yeto.rl.adapters.verl import island_entry, sampler_entry
+from yeto.rl.engine import sample_roles
+
+STORE = "modal-volume://yeto-e9/run"
+
+
+def _tasks(monkeypatch, extra, count):
+    from tests.test_rl_launcher import _Resources, _Storage, _StorageMode, _Task
+    from yeto import launcher
+    from yeto.gpu_spec import parse_gpu_spec
+    from yeto.launch.rl_island_task import make_miles_island_task
+
+    monkeypatch.setitem(sys.modules, "sky", types.SimpleNamespace(
+        Task=_Task, Resources=_Resources, Storage=_Storage, StorageMode=_StorageMode))
+    args = _cli(tuple(extra))
+    launcher._prepare_rl_args(args)
+    args.model_revision, args.data_revision = "a" * 40, "b" * 40
+    args.source_sha256, args.reward_sha256 = "c" * 64, "d" * 64
+    specs = parse_gpu_spec(args.gpu)
+    out = []
+    for m in range(count):
+        task = launcher._island_task(make_miles_island_task, args, specs[m], m, count, "127.0.0.1:1", {})
+        line = next(l for l in task.run.splitlines() if "-m yeto.rl.adapters.verl.island_entry" in l)
+        argv = shlex.split(line.split("-m yeto.rl.adapters.verl.island_entry", 1)[1]
+                           .replace("$LEARNER_ID", str(m)).replace("$SYNCER_ADDR", "127.0.0.1:1"))
+        out.append(island_entry.parse_args(argv)[0])
+    return args, out
+
+
+def test_synced_verl_trainers_and_a_separate_sampler_launch(monkeypatch):
+    """Multi-island sync (S25 C3V shape): N synced trainers read lanes of one store and
+    learner 0 releases; a sampler launch over the same store runs the engine sampler.
+    A relaunched publisher (learner 0) gets the same flags (the fleet controller re-runs
+    the same task), so it re-joins as the publisher."""
+    from yeto.launch.modal_islands import effective_recover_timeout
+    from yeto.rl.engine.merged_release import PUBLISHER_LEARNER_ID
+
+    monkeypatch.setenv("YETO_ISLAND_HMAC_KEY", "k" * 64)  # test key; elastic islands sign messages
+    common = ["--rl-backend", "verl", "--rl-checkpoint-store", STORE, "--rl-max-policy-age", "2",
+              "--reward-function", "gsm8k_reward:score", "--total-steps", "4"]
+    targs, trainers = _tasks(monkeypatch, common + ["--gpu", "modal:1xa10g,modal:1xa10g",
+                                                    "--rl-sample-role", "trainer",
+                                                    "--rl-island-scheduling", "elastic"], 2)
+    for m, t in enumerate(trainers):
+        assert t.rl_sample_role == "trainer" and t.rl_sample_lanes == 2 and t.rl_sample_store
+        assert t.rl_resume_store is None and t.learner_id == m
+        assert island_entry.sample_buffer_section(t)["lane"] == f"{m}/2"
+    assert PUBLISHER_LEARNER_ID == 0
+    assert effective_recover_timeout(targs) > 0  # relaunch allowed: the publisher can be replaced
+    _sargs, (sampler,) = _tasks(monkeypatch, common + ["--gpu", "modal:1xa10g", "--rl-sample-role", "sampler",
+                                                       "--rl-single-island-no-sync"], 1)
+    assert sampler.rl_sample_role == "sampler" and sampler.rl_resume_store == trainers[0].rl_sample_store
+    spec = sampler_entry.sampler_spec(sampler, model_path="/m", prompts_path="/p", card_model="A10G",
+                                      engine_version="v", event_tape="/t")
+    assert spec["sampler_id"] == "island0" and spec["store"] == trainers[0].rl_sample_store
+
+
+def _islands(monkeypatch, roles):
+    from tests.test_rl_launcher import _Resources, _Storage, _StorageMode, _Task
+    from yeto import launcher
+    from yeto.gpu_spec import parse_gpu_spec
+    from yeto.launch.rl_island_task import make_miles_island_task
+
+    monkeypatch.setitem(sys.modules, "sky", types.SimpleNamespace(
+        Task=_Task, Resources=_Resources, Storage=_Storage, StorageMode=_StorageMode))
+    extra = ["--rl-backend", "verl", "--rl-single-island-no-sync", "--rl-checkpoint-store", STORE,
+             "--rl-max-policy-age", "2", "--gpu", ",".join(["modal:1xa10g"] * len(roles)),
+             "--reward-function", "gsm8k_reward:score", "--total-steps", "4"]
+    for m, role in enumerate(roles):
+        extra += ["--rl-island-sample-role", f"{m}:{role}"]
+    args = _cli(tuple(extra))
+    launcher._prepare_rl_args(args)
+    args.model_revision, args.data_revision = "a" * 40, "b" * 40
+    args.source_sha256, args.reward_sha256 = "c" * 64, "d" * 64
+    specs = parse_gpu_spec(args.gpu)
+    out = []
+    for m in range(len(roles)):
+        task = launcher._island_task(make_miles_island_task, args, specs[m], m, len(roles), "none", {})
+        line = next(l for l in task.run.splitlines() if "-m yeto.rl.adapters.verl.island_entry" in l)
+        argv = shlex.split(line.split("-m yeto.rl.adapters.verl.island_entry", 1)[1].replace("$LEARNER_ID", "0"))
+        parsed, _ignored = island_entry.parse_args(argv)
+        out.append((parsed, task.envs))
+    return out
+
+
+def test_one_launch_gives_one_sampler_and_one_trainer(monkeypatch):
+    (sampler, s_env), (trainer, _t_env) = _islands(monkeypatch, ["sampler", "trainer"])
+    assert (sampler.rl_sample_role, trainer.rl_sample_role) == ("sampler", "trainer")
+    assert sampler.rl_sampler_node == "island0" and sampler.rl_resume_store == trainer.rl_resume_store
+    assert island_entry.sample_buffer_section(sampler) is None  # main() runs the engine sampler
+    section = island_entry.sample_buffer_section(trainer)
+    assert section["store"] == trainer.rl_resume_store and "shards" not in section
+    assert s_env.get("YETO_SPOT_RECLAIM_MARKER")  # the reclaim signal reaches the sampler
+    spec = sampler_entry.sampler_spec(sampler, model_path="/m", prompts_path="/p.jsonl", card_model="A10G",
+                                      engine_version="0.x", event_tape="/t/events.jsonl", python="python3")
+    assert spec["sampler_id"] == "island0" and spec["store"] == sampler.rl_resume_store
+    assert spec["engine"]["adapter"] == "vllm-server" and spec["num_rollouts"] == 4
+    assert spec["max_backlog_groups"] == 4 * sample_roles.DEFAULT_MAX_BACKLOG_ROUNDS
+    assert spec["reward"] == "yeto.rl.gsm8k_reward:score" and "buffer_shards" not in spec
+    from yeto.rl.engine.engine_sampler_entry import island_config
+
+    assert island_config(spec).sampler_id == "island0"  # the entry accepts the spec
+
+
+def test_two_samplers_get_shards_and_disjoint_data_slots(monkeypatch):
+    (s0, _), (s1, _), (trainer, _) = _islands(monkeypatch, ["sampler", "sampler", "trainer"])
+    assert (s0.rl_buffer_shards, s1.rl_buffer_shards) == (["island0", "island1"],) * 2
+    assert (s0.rl_sampler_data_slot, s1.rl_sampler_data_slot) == ("0/2", "1/2")
+    assert (s0.global_rounds, s1.global_rounds, trainer.global_rounds) == (2, 2, 4)  # the samplers share the run
+    spec = sampler_entry.sampler_spec(s1, model_path="/m", prompts_path="/p.jsonl", card_model="A10G",
+                                      engine_version="0.x", event_tape="/t/e.jsonl")
+    assert spec["buffer_shards"] == ["island0", "island1"] and spec["prompts"]["data_slot"] == "1/2"
+    assert island_entry.sample_buffer_section(trainer)["shards"] == ["island0", "island1"]
+
+
+def test_sampler_spec_refuses_missing_flags_and_unmapped_rewards():
+    base = dict(rl_sampler_node="island0", rl_resume_store="/s", learner_id=3, groups_per_round=2, rollout_max_response_len=8,
+                samples_per_group=2, seed=1, global_rounds=2, reward_function="gsm8k_reward:score")
+    kw = dict(model_path="/m", prompts_path="/p", card_model="c", engine_version="v", event_tape="/t")
+    with pytest.raises(sampler_entry.SamplerIslandError, match="resume-store"):
+        sampler_entry.sampler_spec(types.SimpleNamespace(**{**base, "rl_resume_store": None}), **kw)
+    # a separate sampler launch (no pair): the Miles sampler's id
+    assert sampler_entry.sampler_spec(types.SimpleNamespace(**{**base, "rl_sampler_node": None}),
+                                      **kw)["sampler_id"] == "island3"
+    with pytest.raises(sampler_entry.SamplerIslandError, match="no engine sampler reward"):
+        sampler_entry.sampler_spec(types.SimpleNamespace(**{**base, "reward_function": "x:y"}), **kw)
+
+
+def test_prompt_rows_render_messages():
+    rows = [{"messages": [{"role": "user", "content": "1+1?", "extra": 0}], "label": 2}]
+    out = sampler_entry.prompt_rows(rows, lambda m: "|".join(x["content"] for x in m))
+    assert out == [{"text": "1+1?", "label": "2"}]
+    with pytest.raises(sampler_entry.SamplerIslandError):
+        sampler_entry.prompt_rows([], str)
+
+
+def test_engine_sampler_writes_its_named_shard(tmp_path):
+    from yeto.rl.engine.engine_sampler_entry import SamplerSpecError, build_stores
+
+    _releases, buffer = build_stores({"store": str(tmp_path), "sampler_id": "island1",
+                                      "buffer_shards": ["island0", "island1"]})
+    assert buffer.shard == "island1"
+    with pytest.raises(SamplerSpecError, match="not one of the buffer shards"):
+        build_stores({"store": str(tmp_path), "sampler_id": "island9", "buffer_shards": ["island0"]})
+
+
+def test_trainer_buffer_merges_named_shards(tmp_path):
+    from yeto.rl.engine.resume import store_for
+    from yeto.rl.engine.sample_buffer import open_trainer_buffer
+
+    buffer = open_trainer_buffer(store_for(str(tmp_path)), batch_size=1, shards=["island0", "island1"])
+    assert buffer._merge and set(buffer._expected_shards) == {"island0", "island1"}
+    plain = open_trainer_buffer(store_for(str(tmp_path / "one")), batch_size=1)
+    assert not plain._merge and plain._expected_shards is None
diff --git a/yeto/rl/adapters/verl/buffer_trainer_runner.py b/yeto/rl/adapters/verl/buffer_trainer_runner.py
index 5601eee2..01de149e 100644
--- a/yeto/rl/adapters/verl/buffer_trainer_runner.py
+++ b/yeto/rl/adapters/verl/buffer_trainer_runner.py
@@ -130,7 +130,8 @@ def call(name, *args, timeout=None):
         store = store_for(section["store"], environ=environ)
         # S25 C3: a synced trainer reads its lane of the buffer (section "lane": "M/N")
         buffer = open_trainer_buffer(store, batch_size=1, create_index=False,
-                                     lane=BufferLane.parse(section.get("lane")))
+                                     lane=BufferLane.parse(section.get("lane")),
+                                     shards=section.get("shards"))
         releases = PolicyReleaseStore(store_for(section.get("release_store") or section["store"],
                                                 environ=environ))
         shape = RowShape(int(config.data.max_prompt_length), int(config.data.max_response_length),
diff --git a/yeto/rl/adapters/verl/island_entry.py b/yeto/rl/adapters/verl/island_entry.py
index ab6f640f..aaa92711 100644
--- a/yeto/rl/adapters/verl/island_entry.py
+++ b/yeto/rl/adapters/verl/island_entry.py
@@ -73,6 +73,13 @@ def parse_args(argv):
     p.add_argument("--rl-sample-role", default=None)
     p.add_argument("--rl-resume-store", default=None)
     p.add_argument("--rl-sample-wait-s", type=float, default=None)
+    # S26 E9.4: the pair flags the launcher forwards per island (sample_roles.island_flags);
+    # a sampler island of a verl launch runs the engine sampler (.sampler_entry)
+    p.add_argument("--rl-sampler-node", default=None)
+    p.add_argument("--rl-buffer-shards", default=None, type=lambda text: [s for s in text.split(",") if s])
+    p.add_argument("--rl-sampler-data-slot", default=None)
+    p.add_argument("--rl-sampler-max-backlog-rounds", type=int, default=None)
+    p.add_argument("--rl-sampler-min-round-seconds", type=float, default=None)
     # S25 C3: a synced trainer island (syncer, learner m of N) reads lane m of the
     # buffer in this store; the launcher forwards both (yeto.rl.engine.merged_release)
     p.add_argument("--rl-sample-store", default=None)
@@ -289,6 +296,15 @@ def main(argv=None) -> int:
     if manifest["problems"]:
         print(f"[yeto-verl] runtime check failed: {manifest['problems']}", file=sys.stderr, flush=True)
         return 2
+    from yeto.rl.engine import sample_roles
+
+    if sample_roles.sample_role(args) == sample_roles.SAMPLER:  # S26 E9.4: no verl trainer here
+        from .sampler_entry import SamplerIslandError, run_sampler_island
+
+        try:
+            return run_sampler_island(args, manifest=manifest, card=_threshold_card(manifest), output=OUTPUT)
+        except SamplerIslandError as error:  # the island flags are incomplete
+            raise SystemExit(str(error)) from None
 
     ray_info = ensure_ray_cpus()
     (OUTPUT / f"verl-ray-{lid}.json").write_text(json.dumps(ray_info, indent=1))
@@ -406,9 +422,11 @@ def sample_buffer_section(args) -> dict | None:
     role = sample_roles.sample_role(args)
     if role == sample_roles.BOTH:
         return None
+    if role == sample_roles.SAMPLER:
+        return None  # main() runs the engine sampler (.sampler_entry) instead of verl
     if role != sample_roles.TRAINER:
-        raise SystemExit(f"--rl-sample-role {role}: a verl island only trains from the buffer; "
-                         "run the sampler as the engine sampler island (yeto.rl.engine.engine_sampler)")
+        raise SystemExit(f"--rl-sample-role {role}: a verl island trains from the buffer or "
+                         "runs the engine sampler (role sampler)")
     if int(args.rl_max_policy_age or 0) < 1:
         raise SystemExit("--rl-sample-role trainer needs --rl-max-policy-age >= 1 (the fully_async path)")
     try:
@@ -417,7 +435,8 @@ def sample_buffer_section(args) -> dict | None:
     except ValueError as error:
         raise SystemExit(str(error)) from None
     config = sample_roles.resolve(args, groups_per_round=args.groups_per_round)
-    return {"store": config.store, "wait_s": config.wait_s, "lane": None if lane is None else lane.env()}
+    return {"store": config.store, "wait_s": config.wait_s, "lane": None if lane is None else lane.env(),
+            **({"shards": list(args.rl_buffer_shards)} if getattr(args, "rl_buffer_shards", None) else {})}
 
 
 def fully_async_plan(limit: int, overrides: list[str], spec_dict: dict | None, args, sync: str):
diff --git a/yeto/rl/adapters/verl/sampler_entry.py b/yeto/rl/adapters/verl/sampler_entry.py
new file mode 100644
index 00000000..1bbe1b20
--- /dev/null
+++ b/yeto/rl/adapters/verl/sampler_entry.py
@@ -0,0 +1,151 @@
+"""The sampler island of a verl launch (S26 E9.4).
+
+``yeto launch --rl-backend verl --rl-island-sample-role 0:sampler,1:trainer``
+starts every island with the verl island entry. A sampler island runs no verl
+trainer: :func:`run_sampler_island` builds the engine sampler spec
+(:mod:`yeto.rl.engine.engine_sampler_entry`) from the island flags and runs the
+engine sampler in-process, on the vLLM of the verl image (adapter
+``vllm-server``). It writes the same buffer and follows the same releases as
+the S25 C2 sampler (which ran SGLang in the Miles image, from an eval script).
+
+* sampler id = ``--rl-sampler-node`` (the launcher's node name in a pair, the
+  buffer shard with several samplers: ``--rl-buffer-shards``), else
+  ``island<learner id>`` (a separate sampler launch beside synced trainers, as
+  the Miles sampler); a replacement incarnation resumes under the same id;
+* store = ``--rl-resume-store`` (the run store the launcher mounts; the trainer
+  reads ``sample-buffer/`` and writes ``policy-releases/`` there);
+* rounds = ``--global-rounds`` (the launcher's share of the run per sampler),
+  ``--groups-per-round`` x ``--samples-per-group`` responses per round;
+* prompts = the train split of ``--data`` rendered with the model's chat
+  template and ``--apply-chat-template-kwargs``; ``--rl-sampler-data-slot``
+  keeps this sampler's slot (several samplers draw disjoint prompts);
+* backlog = ``--rl-sampler-max-backlog-rounds`` rounds (default 4).
+
+:func:`sampler_spec` and :func:`prompt_rows` are pure (unit tested);
+:func:`run_sampler_island` needs the verl image. Not yet run on a GPU.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Callable, Iterable, Mapping
+from pathlib import Path
+from typing import Any
+
+from yeto.rl.adapters.sampler_engines.from_spec import FACTORY as ENGINE_FACTORY
+from yeto.rl.engine.sample_roles import DEFAULT_MAX_BACKLOG_ROUNDS
+
+ENGINE_ADAPTER = "vllm-server"
+MAX_PROMPT_TOKENS = 512  # the verl island's max_prompt (island_entry.main)
+# launcher --reward-function spelling -> the Miles-style reward the engine sampler calls
+SAMPLER_REWARDS = {
+    "gsm8k_reward:score": "yeto.rl.gsm8k_reward:score",
+    "yeto.rl.gsm8k_reward:score": "yeto.rl.gsm8k_reward:score",
+    "yeto.rl.gsm8k_reward.score": "yeto.rl.gsm8k_reward:score",
+}
+
+
+class SamplerIslandError(ValueError):
+    """The flags of a verl sampler island are incomplete."""
+
+
+def sampler_reward(reward_function: str) -> str:
+    try:
+        return SAMPLER_REWARDS[reward_function]
+    except KeyError:
+        raise SamplerIslandError(f"no engine sampler reward for {reward_function!r} "
+                                 f"(mapped: {sorted(SAMPLER_REWARDS)})") from None
+
+
+def prompt_rows(rows: Iterable[Mapping[str, Any]], render: Callable[[list], str]) -> list[dict[str, str]]:
+    """``{"text", "label"}`` records of the dataset rows (``messages``, ``label``)."""
+    out = []
+    for row in rows:
+        messages = [{"role": m["role"], "content": m["content"]} for m in row["messages"]]
+        out.append({"text": render(messages), "label": str(row["label"])})
+    if not out:
+        raise SamplerIslandError("the prompt data has no rows")
+    return out
+
+
+def sampler_spec(args: Any, *, model_path: str, prompts_path: str, card_model: str, engine_version: str,
+                 device_family: str = "cuda", event_tape: str, python: str = sys.executable,
+                 gpu_memory_utilization: float = 0.5) -> dict[str, Any]:
+    """The engine sampler spec of one verl sampler island (module doc)."""
+    sampler_id = getattr(args, "rl_sampler_node", None) or f"island{int(args.learner_id)}"
+    store = getattr(args, "rl_resume_store", None)
+    if not store:
+        raise SamplerIslandError("a verl sampler island needs --rl-resume-store (the run store)")
+    groups = int(args.groups_per_round)
+    backlog = int(getattr(args, "rl_sampler_max_backlog_rounds", None) or DEFAULT_MAX_BACKLOG_ROUNDS)
+    max_len = MAX_PROMPT_TOKENS + int(args.rollout_max_response_len)
+    spec: dict[str, Any] = {
+        "sampler_id": str(sampler_id),
+        "engine": {"factory": ENGINE_FACTORY, "adapter": ENGINE_ADAPTER,
+                   "server": {"base_dir": str(model_path), "card_model": card_model,
+                              "device_family": device_family, "engine_version": engine_version,
+                              "precision": "bf16", "quant_scheme": "bf16", "topology": "tp1",
+                              "max_model_len": max_len, "port": 30000, "python": python,
+                              "start_timeout_s": 1200.0,
+                              "extra_args": ["--gpu-memory-utilization", f"{float(gpu_memory_utilization):g}"]},
+                   "options": {"tp": 1, "served_model_name": "yeto-policy"}},
+        "sampling": {"max_tokens": int(args.rollout_max_response_len), "temperature": 1.0, "top_p": 1.0,
+                     "top_k": -1, "n": int(args.samples_per_group), "seed": int(args.seed)},
+        "num_rollouts": int(args.global_rounds),
+        "max_backlog_groups": groups * backlog,
+        "max_prompt_tokens": MAX_PROMPT_TOKENS,
+        "base_version": 0, "base_dir": str(model_path),
+        "store": str(store),
+        "prompts": {"path": str(prompts_path), "input_key": "text", "label_key": "label",
+                    "groups_per_round": groups, "format": "text"},
+        "reward": sampler_reward(args.reward_function), "reward_kind": "miles",
+        "checks": {"expected_expert_matrices": None, "fixed_prompts": []},
+        "event_tape": str(event_tape),
+    }
+    if getattr(args, "rl_sampler_data_slot", None):
+        spec["prompts"]["data_slot"] = str(args.rl_sampler_data_slot)
+    if getattr(args, "rl_buffer_shards", None):
+        spec["buffer_shards"] = list(args.rl_buffer_shards)
+    if getattr(args, "rl_sampler_min_round_seconds", None) is not None:
+        spec["min_round_s"] = float(args.rl_sampler_min_round_seconds)
+    return spec
+
+
+def run_sampler_island(args: Any, *, manifest: Mapping[str, Any], card: str, output: Path) -> int:
+    """The island process of a verl sampler island (verl image)."""
+    import os
+
+    import pandas as pd
+    from huggingface_hub import hf_hub_download, snapshot_download
+    from transformers import AutoTokenizer
+
+    from yeto.rl.engine import engine_sampler_entry as entry
+
+    model_path = snapshot_download(args.model, revision=args.model_revision)
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    chat = json.loads(args.apply_chat_template_kwargs) if args.apply_chat_template_kwargs else {}
+    frame = pd.read_parquet(hf_hub_download(args.data, "train.parquet", repo_type="dataset",
+                                            revision=args.data_revision))
+    work = Path(os.path.expanduser("~/yeto-verl/sampler"))
+    work.mkdir(parents=True, exist_ok=True)
+    prompts = work / "prompts.jsonl"
+    rows = prompt_rows((row for _, row in frame.iterrows()), lambda messages: tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True, **chat))
+    prompts.write_text("".join(json.dumps(r) + "\n" for r in rows), encoding="utf-8")
+    versions = manifest.get("versions") or {}
+    spec = sampler_spec(args, model_path=model_path, prompts_path=str(prompts),
+                        card_model=card,
+                        engine_version=str(versions.get("vllm")),
+                        device_family=str(manifest.get("device_family") or "cuda"),
+                        event_tape=os.path.expanduser(args.event_tape),
+                        gpu_memory_utilization=float(os.environ.get("YETO_VERL_GPU_MEM", "0.5")))
+    (output / f"verl-sampler-spec-{args.learner_id}.json").write_text(json.dumps(spec, indent=1))
+    try:
+        rounds = entry.run(spec)
+    except entry.SamplerSpecError as error:
+        print(f"[yeto-verl] sampler spec rejected: {error}", file=sys.stderr, flush=True)
+        return 2
+    print(f"[yeto-verl] sampler island {spec['sampler_id']} ran {rounds} rounds", flush=True)
+    entry.hold_after_reclaim()  # reclaimed: let the cloud run the island again
+    return 0
diff --git a/yeto/rl/engine/engine_sampler_entry.py b/yeto/rl/engine/engine_sampler_entry.py
index d91694d0..884aabb4 100644
--- a/yeto/rl/engine/engine_sampler_entry.py
+++ b/yeto/rl/engine/engine_sampler_entry.py
@@ -20,7 +20,10 @@
   needs the store environment of :mod:`yeto.cloud.oss_store`);
   ``release_dir``: the release directory the sampler follows (optional,
   default ``policy-releases``); ``buffer_root``: the store holding
-  ``sample-buffer/`` (optional, default ``store``);
+  ``sample-buffer/`` (optional, default ``store``); ``buffer_shards``: the
+  sampler shards of a run with several samplers on one shared directory
+  (optional; the sampler writes its own shard, the trainer merges them, as
+  ``--rl-buffer-shards`` on the Miles sampler);
 * ``prompts``: ``{"path": JSONL, "input_key", "label_key", "groups_per_round",
   "format": "text" | "chat"}`` -- round ``r`` takes the
   ``groups_per_round`` rows after row ``r * groups_per_round`` (wrapping);
@@ -219,7 +222,10 @@ def build_stores(spec: Mapping[str, Any], environ: Mapping[str, str] | None = No
                                   release_dir=str(spec.get("release_dir") or RELEASE_DIR))
     buffer_store = store_for(str(spec.get("buffer_root") or store), environ=environ)
     sampler_id = str(_require(spec, "sampler_id"))
-    index = shard_index(sampler_id) if needs_shards(buffer_store) else INDEX
+    shards = [str(s) for s in spec.get("buffer_shards") or ()]
+    if shards and sampler_id not in shards:
+        raise SamplerSpecError(f"sampler {sampler_id!r} is not one of the buffer shards {shards}")
+    index = shard_index(sampler_id) if needs_shards(buffer_store) or shards else INDEX
     return releases, FileSampleBuffer(buffer_store, batch_size=1, index=index)  # as open_buffer(sampler=True)
 
 
diff --git a/yeto/rl/engine/sample_buffer.py b/yeto/rl/engine/sample_buffer.py
index aa271588..d5da89cd 100644
--- a/yeto/rl/engine/sample_buffer.py
+++ b/yeto/rl/engine/sample_buffer.py
@@ -356,12 +356,16 @@ def index_for(store: CheckpointStore | ObjectStore, *, index: str = INDEX,
 
 def open_trainer_buffer(store: CheckpointStore | ObjectStore, *, batch_size: int,
                         lane: BufferLane | None = None, create_index: bool = True,
-                        **kwargs: Any) -> "FileSampleBuffer":
+                        shards: Iterable[str] | None = None, **kwargs: Any) -> "FileSampleBuffer":
     """The buffer of a trainer (the reader): it merges the sampler shards of a
-    store that shards (:func:`needs_shards`) unless it is a synced trainer other
-    than the publisher (``merged_release.merges_shards``); ``lane``: its lane."""
+    store that shards (:func:`needs_shards`), or the named ``shards`` of several
+    sampler islands on one shared directory (the data ends once every named
+    shard ended), unless it is a synced trainer other than the publisher
+    (``merged_release.merges_shards``); ``lane``: its lane."""
+    named = tuple(shards or ())
+    merge = (needs_shards(store) or bool(named)) and merges_shards(lane)
     return FileSampleBuffer(store, batch_size=batch_size, create_index=create_index, lane=lane,
-                            merge_shards=needs_shards(store) and merges_shards(lane), **kwargs)
+                            merge_shards=merge, expected_shards=named if merge and named else None, **kwargs)
 
 
 class FileSampleBuffer:

From ef3429301ef84544b3d37bf74a9db2624bd28708 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:58:25 +0000
Subject: [PATCH 07/23] Test: a resumable trainer island on Modal also gets the
 reclaim marker path (E9.1)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_rl_spot_sampler_replace.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/test_rl_spot_sampler_replace.py b/tests/test_rl_spot_sampler_replace.py
index cbe2e7fa..43dcf870 100644
--- a/tests/test_rl_spot_sampler_replace.py
+++ b/tests/test_rl_spot_sampler_replace.py
@@ -339,7 +339,10 @@ def test_the_island_resolves_its_sampler_id_and_the_shards():
     assert (env[br.SAMPLER_ID_ENV], env[br.SHARDS_ENV]) == ("island1", "island0,island1")
 
 
-def test_only_sampler_islands_get_the_reclaim_marker():
+def test_sampler_and_resumable_trainer_islands_get_the_reclaim_marker():
+    """S25 C1: the sampler islands; S26 E9.1: also the trainer, a resumable island on
+    Modal (--rl-checkpoint-store), whose driver turns the marker into the preemption
+    notice."""
     from yeto.gpu_spec import parse_gpu_spec
     from yeto.launch.modal_islands import build_modal_island_config
     from yeto.launcher import _island_task, make_miles_island_task
@@ -348,7 +351,7 @@ def test_only_sampler_islands_get_the_reclaim_marker():
     for m, spec in enumerate(parse_gpu_spec(args.gpu)):
         task = _island_task(make_miles_island_task, args, spec, m, 3, "none", {})
         cfg = build_modal_island_config(args, spec, m, task, "none")
-        assert (RECLAIM_MARKER_ENV in cfg.envs) == (m < 2)
+        assert RECLAIM_MARKER_ENV in cfg.envs, m
 
 
 def test_two_samplers_refuse_the_trainer_scheduler():

From 4079f758a131bfff10d7021b65fdbf0a954a7ed2 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 15:58:25 +0000
Subject: [PATCH 08/23] verl sampler entry names the engine factory by path (no
 adapter-to-adapter import)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_verl_pair_launch.py  | 3 +++
 yeto/rl/adapters/verl/sampler_entry.py | 4 +++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/test_s26_e9_verl_pair_launch.py b/tests/test_s26_e9_verl_pair_launch.py
index 8480fa0d..96fd8559 100644
--- a/tests/test_s26_e9_verl_pair_launch.py
+++ b/tests/test_s26_e9_verl_pair_launch.py
@@ -115,6 +115,9 @@ def test_one_launch_gives_one_sampler_and_one_trainer(monkeypatch):
     from yeto.rl.engine.engine_sampler_entry import island_config
 
     assert island_config(spec).sampler_id == "island0"  # the entry accepts the spec
+    from yeto.rl.adapters.sampler_engines import from_spec
+
+    assert spec["engine"]["factory"] == from_spec.FACTORY
 
 
 def test_two_samplers_get_shards_and_disjoint_data_slots(monkeypatch):
diff --git a/yeto/rl/adapters/verl/sampler_entry.py b/yeto/rl/adapters/verl/sampler_entry.py
index 1bbe1b20..1ff3de3f 100644
--- a/yeto/rl/adapters/verl/sampler_entry.py
+++ b/yeto/rl/adapters/verl/sampler_entry.py
@@ -33,9 +33,11 @@
 from pathlib import Path
 from typing import Any
 
-from yeto.rl.adapters.sampler_engines.from_spec import FACTORY as ENGINE_FACTORY
 from yeto.rl.engine.sample_roles import DEFAULT_MAX_BACKLOG_ROUNDS
 
+# the spec names the engine factory by its import path; an adapter does not import
+# another adapter (import boundaries, yeto/rl/engine/README.md)
+ENGINE_FACTORY = "yeto.rl.adapters.sampler_engines.from_spec:build"
 ENGINE_ADAPTER = "vllm-server"
 MAX_PROMPT_TOKENS = 512  # the verl island's max_prompt (island_entry.main)
 # launcher --reward-function spelling -> the Miles-style reward the engine sampler calls

From cc8eba89c3e0806267cff0df852ddd86dea0e345 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 16:13:02 +0000
Subject: [PATCH 09/23] Relay a rank>0 Modal reclaim to the rank-0 driver; one
 launch for synced trainers and their samplers

- modal_runner: on a multi-node island rank 0's runner listens on a small relay
  port; a rank>0 runner that gets SIGINT/SIGTERM sends the signal there, and
  rank 0 writes the reclaim marker its driver watcher turns into the store's
  preemption notice (signal names the source rank).
- sample_roles: a synced group (--rl-sample-role trainer with a syncer plus
  --rl-island-sample-role M:sampler) starts K synced trainers (learners 0..K-1,
  lanes K) and no-sync sampler islands over the same store in one launch; the
  samplers split K x total-steps rounds, take data slots and buffer shards.
- launcher: the syncer counts only the trainers of a synced group.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_preempt_marker.py   |  61 +++++++++++++
 tests/test_s26_e9_verl_pair_launch.py |  85 +++++++++++++++++
 yeto/launch/rl_ports.py               |   2 +-
 yeto/launcher.py                      |  13 ++-
 yeto/modal_runner.py                  | 119 ++++++++++++++++++++++--
 yeto/rl/engine/resume.py              |  10 +-
 yeto/rl/engine/sample_roles.py        | 127 +++++++++++++++++++++++---
 7 files changed, 388 insertions(+), 29 deletions(-)

diff --git a/tests/test_s26_e9_preempt_marker.py b/tests/test_s26_e9_preempt_marker.py
index b0f53e24..c376afed 100644
--- a/tests/test_s26_e9_preempt_marker.py
+++ b/tests/test_s26_e9_preempt_marker.py
@@ -138,3 +138,64 @@ def wire(driver, resume, **kw):
     notices = Path(resume.controller.checkpoint_store) / "preempt-notices"
     assert _wait(lambda: any(notices.glob("*.json")))
     assert json.loads(next(notices.glob("*.json")).read_text())["signal"] == "SIGINT (reclaim marker)"
+
+
+def test_rank1_reclaim_reaches_the_rank0_driver_through_the_relay(tmp_path):
+    """Known limit fixed: a reclaim of a rank>0 container of a multi-node island is
+    relayed by its runner to rank 0, whose marker the driver watcher turns into the notice."""
+    from yeto import modal_runner
+
+    marker0, marker1 = tmp_path / "reclaim0", tmp_path / "reclaim1"
+    controller = _controller(tmp_path)
+    watcher = watch_preempt_marker(controller, environ={RECLAIM_MARKER_ENV: str(marker0)}, poll_s=0.02,
+                                   out=io.StringIO())
+    relay = modal_runner.ReclaimRelay(
+        lambda num, peer: modal_runner._write_reclaim_marker(str(marker0), num, time.time, from_rank=peer),
+        port=0, host="127.0.0.1").start()
+    try:
+        env1 = {RECLAIM_MARKER_ENV: str(marker1), "SKYPILOT_NODE_RANK": "1",
+                "SKYPILOT_NODE_IPS": "127.0.0.1\n127.0.0.2",
+                modal_runner.RECLAIM_RELAY_PORT_ENV: str(relay.port)}
+        handlers = {}
+        sig = SimpleNamespace(SIGINT=signal.SIGINT, SIGTERM=signal.SIGTERM,
+                              signal=lambda num, fn: handlers.__setitem__(num, fn))
+
+        class Proc:
+            def wait(self):
+                handlers[signal.SIGINT](signal.SIGINT, None)
+                return 0
+
+        assert modal_runner._run_forwarding_to_learner(["true"], env1, popen=lambda cmd, env: Proc(),
+                                                       sig=sig) == 0
+        assert marker1.exists() and marker0.exists()
+        notices = tmp_path / "store" / "preempt-notices"
+        assert _wait(lambda: any(notices.glob("*.json")))
+        record = json.loads(next(notices.glob("*.json")).read_text())
+        assert record["signal"] == "SIGINT (reclaim marker, rank 1)"
+    finally:
+        relay.stop()
+        watcher.stop()
+
+
+def test_rank0_of_a_multi_node_island_starts_the_relay(tmp_path):
+    from yeto import modal_runner
+
+    env = {RECLAIM_MARKER_ENV: str(tmp_path / "m"), "SKYPILOT_NODE_RANK": "0",
+           "SKYPILOT_NODE_IPS": "127.0.0.1\n127.0.0.2", modal_runner.RECLAIM_RELAY_PORT_ENV: "0"}
+    seen = {}
+    sig = SimpleNamespace(SIGINT=signal.SIGINT, SIGTERM=signal.SIGTERM, signal=lambda num, fn: None)
+
+    class Proc:
+        def wait(self):
+            seen["relay"] = [t.name for t in threading.enumerate() if t.name == "reclaim-relay"]
+            return 0
+
+    assert modal_runner._run_forwarding_to_learner(["true"], env, popen=lambda cmd, env: Proc(), sig=sig) == 0
+    assert seen["relay"] == ["reclaim-relay"]
+    assert not any(t.name == "reclaim-relay" for t in threading.enumerate())
+
+
+def test_relay_send_fails_softly_when_rank0_is_gone():
+    from yeto import modal_runner
+
+    assert modal_runner.send_reclaim_to_rank0("127.0.0.1", 1, 2, 1, timeout_s=0.2, attempts=1) is False
diff --git a/tests/test_s26_e9_verl_pair_launch.py b/tests/test_s26_e9_verl_pair_launch.py
index 96fd8559..ee6061da 100644
--- a/tests/test_s26_e9_verl_pair_launch.py
+++ b/tests/test_s26_e9_verl_pair_launch.py
@@ -170,3 +170,88 @@ def test_trainer_buffer_merges_named_shards(tmp_path):
     assert buffer._merge and set(buffer._expected_shards) == {"island0", "island1"}
     plain = open_trainer_buffer(store_for(str(tmp_path / "one")), batch_size=1)
     assert not plain._merge and plain._expected_shards is None
+
+
+def _group(monkeypatch, gpus, samplers, total_steps=4):
+    """One launch of synced trainers plus sampler islands (S26 E9.4 synced group)."""
+    from tests.test_rl_launcher import _Resources, _Storage, _StorageMode, _Task
+    from yeto import launcher
+    from yeto.gpu_spec import parse_gpu_spec
+    from yeto.launch.rl_island_task import make_miles_island_task
+
+    monkeypatch.setenv("YETO_ISLAND_HMAC_KEY", "k" * 64)  # test key; elastic islands sign messages
+    monkeypatch.setitem(sys.modules, "sky", types.SimpleNamespace(
+        Task=_Task, Resources=_Resources, Storage=_Storage, StorageMode=_StorageMode))
+    extra = ["--rl-backend", "verl", "--rl-checkpoint-store", STORE, "--rl-max-policy-age", "2",
+             "--reward-function", "gsm8k_reward:score", "--total-steps", str(total_steps),
+             "--gpu", ",".join(["modal:1xa10g"] * gpus), "--rl-sample-role", "trainer",
+             "--rl-island-scheduling", "elastic"]
+    for m in samplers:
+        extra += ["--rl-island-sample-role", f"{m}:sampler"]
+    args = _cli(tuple(extra))
+    launcher._prepare_rl_args(args)
+    args.model_revision, args.data_revision = "a" * 40, "b" * 40
+    args.source_sha256, args.reward_sha256 = "c" * 64, "d" * 64
+    specs = parse_gpu_spec(args.gpu)
+    learners = sample_roles.syncer_learner_count(args, len(specs))
+    out = []
+    for m in range(len(specs)):
+        task = launcher._island_task(make_miles_island_task, args, specs[m], m, learners, "127.0.0.1:1", {})
+        line = next(l for l in task.run.splitlines() if "-m yeto.rl.adapters.verl.island_entry" in l)
+        argv = shlex.split(line.split("-m yeto.rl.adapters.verl.island_entry", 1)[1]
+                           .replace("$LEARNER_ID", task.envs["LEARNER_ID"]).replace("$SYNCER_ADDR", "127.0.0.1:1"))
+        out.append((island_entry.parse_args(argv)[0], task, line))
+    return args, learners, out
+
+
+def test_one_launch_starts_synced_trainers_and_their_sampler(monkeypatch):
+    """Known limit fixed: synced trainers and a sampler start from one command."""
+    args, learners, ((t0, _, l0), (t1, _, l1), (s, s_task, s_line)) = _group(monkeypatch, 3, [2])
+    assert sample_roles.is_synced_group(args) and not sample_roles.is_pair(args)
+    assert learners == 2  # the syncer waits for the two trainers only
+    for k, t in enumerate((t0, t1)):
+        assert t.rl_sample_role == "trainer" and t.learner_id == k and t.rl_sample_lanes == 2
+        assert t.rl_sample_store and t.rl_resume_store is None
+        assert island_entry.sample_buffer_section(t)["lane"] == f"{k}/2"
+        assert "shards" not in island_entry.sample_buffer_section(t)  # one sampler writes the index
+    assert "--rl-island-scheduling elastic" in l0 and "--syncer" in l1
+    assert s.rl_sample_role == "sampler" and s.rl_sampler_node == "island2"
+    assert s.rl_resume_store == t0.rl_sample_store  # the same store
+    assert "--rl-single-island-no-sync" in s_line and "--rl-island-scheduling" not in s_line
+    assert s_task.envs["LEARNER_ID"] == "0" and s_task.envs.get("YETO_SPOT_RECLAIM_MARKER")
+    spec = sampler_entry.sampler_spec(s, model_path="/m", prompts_path="/p", card_model="A10G",
+                                      engine_version="v", event_tape="/t")
+    assert spec["num_rollouts"] == 8  # the rounds of both trainers (2 x 4)
+
+
+def test_synced_group_with_two_samplers_shards_and_slots(monkeypatch):
+    _args, learners, islands = _group(monkeypatch, 4, [0, 3])
+    (s0, _, _), (t0, _, _), (t1, _, _), (s1, _, _) = islands
+    assert learners == 2 and (t0.learner_id, t1.learner_id) == (0, 1)
+    assert island_entry.sample_buffer_section(t0)["shards"] == ["island0", "island3"]
+    assert (s0.rl_sampler_data_slot, s1.rl_sampler_data_slot) == ("0/2", "1/2")
+    for s in (s0, s1):
+        spec = sampler_entry.sampler_spec(s, model_path="/m", prompts_path="/p", card_model="A10G",
+                                          engine_version="v", event_tape="/t")
+        assert spec["num_rollouts"] == 4  # 2 trainers x 4 rounds over 2 samplers
+
+
+@pytest.mark.parametrize("gpus,samplers,steps,match", [
+    (2, [1], 4, "at least two trainer"),
+    (3, [2], 3, None),  # 2 x 3 rounds over one sampler: fine
+    (4, [2, 3], 3, None),  # 2 x 3 = 6 over 2 samplers: fine
+])
+def test_synced_group_launch_checks(monkeypatch, gpus, samplers, steps, match):
+    if match is None:
+        _group(monkeypatch, gpus, samplers, total_steps=steps)
+        return
+    with pytest.raises((ValueError, SystemExit), match=match):
+        _group(monkeypatch, gpus, samplers, total_steps=steps)
+
+
+def test_synced_group_lists_samplers_only():
+    args = types.SimpleNamespace(rl_island_sample_role=["0:trainer", "2:sampler"], rl_sample_role="trainer",
+                                 rl_single_island_no_sync=False, tuning="lora", total_steps=4,
+                                 rl_node_class=None)
+    with pytest.raises(ValueError, match="sampler islands only"):
+        sample_roles.check_synced_group(args, 3)
diff --git a/yeto/launch/rl_ports.py b/yeto/launch/rl_ports.py
index 63b41f24..c2d7401f 100644
--- a/yeto/launch/rl_ports.py
+++ b/yeto/launch/rl_ports.py
@@ -566,7 +566,7 @@ def _ports_infra_flags(args) -> tuple[str, str]:
     if resume_store is not None and sample_role_is_synced_trainer(args):
         # S25 C3: synced trainers mount the store for the buffer and the releases only
         flags += (f" --rl-sample-store {shlex.quote(resume_store[0])}"
-                  f" --rl-sample-lanes {rl_island_count(args)}")
+                  f" --rl-sample-lanes {getattr(args, 'rl_synced_trainers', None) or rl_island_count(args)}")
         resume_store = None
     if resume_store is not None:  # rl-resume-from-checkpoint: non-elastic resume store
         flags += f" --rl-resume-store {shlex.quote(resume_store[0])}"
diff --git a/yeto/launcher.py b/yeto/launcher.py
index 989cbbc7..969a46d6 100644
--- a/yeto/launcher.py
+++ b/yeto/launcher.py
@@ -184,7 +184,7 @@ def _island_task(task_factory, args, spec, m, num_learners, syncer_addr, overrid
     iargs = droppable.role_args(io.island_args(rl_island_args(args, m), m, overrides), role)
     # L5.4 pair: the island's sample role; it runs as learner 0 of 1 (no syncer).
     iargs = sample_roles.island_args(iargs, m, rl_island_count(args))
-    learner_id, island_learners = sample_roles.island_learner(args, m, num_learners)
+    learner_id, island_learners = sample_roles.island_learner(args, m, num_learners, rl_island_count(args))
     task = task_factory(iargs, spec, learner_id, island_learners, syncer_addr)
     io.apply_to_task(task, {**io.island_env(args, m, overrides),
                             **(droppable.role_env(role, spec.cloud, spec.region) if role else {}),
@@ -318,7 +318,10 @@ def run(args, on_clusters=None, local_syncer=None, on_instance_ids=None) -> int:
     # counts them in --learners and its port is already public, so they
     # simply dial in with the printed join command.
     external = max(0, getattr(args, "external_learners", 0) or 0)
-    num_learners = len(specs) + external
+    from .rl.engine import sample_roles
+
+    # S26 E9.4: the sampler islands of a synced group are no learners of the syncer
+    num_learners = sample_roles.syncer_learner_count(args, len(specs)) + external
     require_modal_for_gpu_exact(args, specs)
     warn_if_model_wont_fit(args, specs)
     prefix = args.cluster_prefix
@@ -1015,13 +1018,15 @@ def dry_run_plan(args) -> dict:
         if rl:
             role = _island_role(args, specs, learner_id)
             task = _island_task(make_miles_island_task, args, spec, learner_id,
-                                len(specs) + external, "$SYNCER_ADDR", island_overrides, role)
+                                sample_roles.syncer_learner_count(args, len(specs)) + external,
+                                "$SYNCER_ADDR", island_overrides, role)
             if role is not None:
                 from .cloud.droppable import billing, rejoin_source
 
                 entry["island_role"] = {"role": role, "billing": billing(role),
                                         "rejoin": rejoin_source(role)}
-            if sample_roles.is_store_coupled(args):  # L5.4/L7.5: per-island role, learner 0 of 1
+            if sample_roles.is_store_coupled(args) or sample_roles.is_synced_group(args):
+                # L5.4/L7.5: per-island role, learner 0 of 1; S26 E9.4: synced group
                 entry["sample_role"] = sample_roles.island_args(
                     args, learner_id, len(specs)).rl_sample_role
             if learner_id == trainer_loop.held_island(args):
diff --git a/yeto/modal_runner.py b/yeto/modal_runner.py
index 19ba5353..e5af4919 100644
--- a/yeto/modal_runner.py
+++ b/yeto/modal_runner.py
@@ -951,22 +951,121 @@ def _run_forwarding_to_learner(cmd: list[str], env: dict, *, popen, sig, clock=t
     marker file the learner's watcher thread picks up. Nothing is signalled: the
     learner and the Ray processes keep running until the platform kills the
     container, so the rollout executor can answer the in-flight export."""
-    proc = popen(cmd, env=env)
     path = env.get("YETO_SPOT_RECLAIM_MARKER") or "/tmp/yeto-reclaim-requested"
+    rank, node_ips = _node_rank_and_ips(env)
+    relay = None
+    if rank == 0 and len(node_ips) > 1:
+        # S26 E9.1: the driver runs on rank 0; a reclaim of a rank>0 container reaches
+        # it only through this relay (the peer runner sends its signal over the cluster net)
+        relay = ReclaimRelay(lambda num, peer: _write_reclaim_marker(path, num, clock, from_rank=peer),
+                             port=reclaim_relay_port(env)).start()
+    proc = popen(cmd, env=env)
 
     def forward(num, _frame):
-        try:
-            tmp = f"{path}.tmp"
-            with open(tmp, "w", encoding="utf-8") as fh:
-                fh.write(json.dumps({"signal": int(num), "time": clock()}) + "\n")
-            os.replace(tmp, path)
-            print(f"[modal-island] signal {num}: reclaim marker {path} written for the learner", flush=True)
-        except OSError as exc:
-            print(f"[modal-island] signal {num}: reclaim marker not written ({exc})", flush=True)
+        _write_reclaim_marker(path, num, clock, from_rank=rank)
+        if rank > 0 and node_ips:
+            send_reclaim_to_rank0(node_ips[0], reclaim_relay_port(env), num, rank)
 
     for name in ("SIGINT", "SIGTERM"):
         sig.signal(getattr(sig, name), forward)
-    return proc.wait()
+    try:
+        return proc.wait()
+    finally:
+        if relay is not None:
+            relay.stop()
+
+
+RECLAIM_RELAY_PORT_ENV = "YETO_RECLAIM_RELAY_PORT"
+RECLAIM_RELAY_PORT_DEFAULT = 29417
+
+
+def reclaim_relay_port(env: dict) -> int:
+    return int(env.get(RECLAIM_RELAY_PORT_ENV) or RECLAIM_RELAY_PORT_DEFAULT)
+
+
+def _node_rank_and_ips(env: dict) -> tuple[int, list[str]]:
+    """This container's rank and the cluster's node ips (from :func:`skypilot_env`)."""
+    ips = [ip for ip in (env.get("SKYPILOT_NODE_IPS") or "").splitlines() if ip.strip()]
+    return int(env.get("SKYPILOT_NODE_RANK") or 0), ips
+
+
+def _write_reclaim_marker(path: str, num: int, clock, *, from_rank: int) -> None:
+    """Write the reclaim marker the learner's watcher polls; report, never raise
+    (it runs in a signal handler or the relay thread)."""
+    try:
+        tmp = f"{path}.{os.getpid()}.{threading.get_ident()}.tmp"
+        with open(tmp, "w", encoding="utf-8") as fh:
+            fh.write(json.dumps({"signal": int(num), "time": clock(), "rank": int(from_rank)}) + "\n")
+        os.replace(tmp, path)
+        print(f"[modal-island] signal {num} (rank {from_rank}): reclaim marker {path} written for the learner",
+              flush=True)
+    except OSError as exc:
+        print(f"[modal-island] signal {num} (rank {from_rank}): reclaim marker not written ({exc})", flush=True)
+
+
+def send_reclaim_to_rank0(host: str, port: int, num: int, rank: int, *, timeout_s: float = 2.0,
+                          attempts: int = 3) -> bool:
+    """A rank>0 runner tells rank 0's relay that this container is being reclaimed.
+    Short timeouts: it runs inside Modal's grace window. Returns True once acked."""
+    msg = (json.dumps({"signal": int(num), "rank": int(rank)}) + "\n").encode()
+    for attempt in range(attempts):
+        try:
+            with socket.create_connection((host, port), timeout=timeout_s) as conn:
+                conn.sendall(msg)
+                conn.settimeout(timeout_s)
+                if conn.recv(16).startswith(b"ok"):
+                    print(f"[modal-island] signal {num}: relayed to rank 0 at {host}:{port}", flush=True)
+                    return True
+        except OSError as exc:
+            print(f"[modal-island] signal {num}: relay to rank 0 failed (attempt {attempt + 1}: {exc})",
+                  flush=True)
+            time.sleep(0.2)
+    return False
+
+
+class ReclaimRelay:
+    """On rank 0 of a multi-node island: accept reclaim messages from peer runners
+    and hand each to ``on_reclaim(signal, rank)`` (which writes the local marker)."""
+
+    def __init__(self, on_reclaim, *, port: int, host: str = "0.0.0.0") -> None:
+        self.on_reclaim, self.host, self.port = on_reclaim, host, port
+        self._sock: socket.socket | None = None
+        self._thread: threading.Thread | None = None
+        self._stop = threading.Event()
+
+    def start(self) -> "ReclaimRelay":
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((self.host, self.port))
+        sock.listen(8)
+        sock.settimeout(0.5)
+        self._sock, self.port = sock, sock.getsockname()[1]
+        self._thread = threading.Thread(target=self._serve, name="reclaim-relay", daemon=True)
+        self._thread.start()
+        print(f"[modal-island] reclaim relay listening on port {self.port}", flush=True)
+        return self
+
+    def _serve(self) -> None:
+        while not self._stop.is_set():
+            try:
+                conn, _addr = self._sock.accept()
+            except (socket.timeout, OSError):
+                continue
+            with conn:
+                try:
+                    conn.settimeout(2.0)
+                    doc = json.loads(conn.makefile("r", encoding="utf-8").readline())
+                    self.on_reclaim(int(doc["signal"]), int(doc["rank"]))
+                    conn.sendall(b"ok\n")
+                except (OSError, ValueError, KeyError, TypeError) as exc:
+                    print(f"[modal-island] reclaim relay: bad message ({exc})", flush=True)
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self._sock is not None:
+            self._sock.close()
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
 
 
 class ModalOps:
diff --git a/yeto/rl/engine/resume.py b/yeto/rl/engine/resume.py
index 38ee93db..954e8a83 100644
--- a/yeto/rl/engine/resume.py
+++ b/yeto/rl/engine/resume.py
@@ -594,12 +594,16 @@ def watch_preempt_marker(controller: "ResumeController", *, environ: Mapping[str
     marker = reclaim_marker(env)
 
     def on_reclaim() -> None:
+        rank = 0
         try:
-            signum = int(json.loads(marker.read_text(encoding="utf-8")).get("signal"))
-            name = signal_name(signum)
+            doc = json.loads(marker.read_text(encoding="utf-8"))
+            name = signal_name(int(doc.get("signal")))
+            rank = int(doc.get("rank") or 0)
         except (OSError, ValueError, TypeError, AttributeError):
             name = "unknown"
-        record = write_preempt_marker(controller.checkpoint_store, signal_name=f"{name} (reclaim marker)",
+        # a multi-node island: the Modal runner of rank>0 relays its signal to rank 0
+        source = "reclaim marker" if rank == 0 else f"reclaim marker, rank {rank}"
+        record = write_preempt_marker(controller.checkpoint_store, signal_name=f"{name} ({source})",
                                       incarnation=controller.incarnation, rollout_id=None,
                                       store=controller.store)
         print(f"[yeto] rl_preempt_notice {json.dumps(record, sort_keys=True)}", file=out or sys.stdout,
diff --git a/yeto/rl/engine/sample_roles.py b/yeto/rl/engine/sample_roles.py
index 22e4c840..418c6c73 100644
--- a/yeto/rl/engine/sample_roles.py
+++ b/yeto/rl/engine/sample_roles.py
@@ -28,8 +28,12 @@
 reads lane m of the buffer; the island with learner id 0 releases the merged
 policy. The store reaches the island as ``--rl-sample-store`` (buffer and
 releases only: multi-island round cuts do not exist), the trainer count as
-``--rl-sample-lanes``. The samplers are separate
-no-sync launches over the same store.
+``--rl-sample-lanes``. The samplers are separate no-sync launches over the
+same store, or (S26 E9.4) islands of the same launch, a *synced group*
+(``--rl-sample-role trainer --rl-island-sample-role M:sampler``, a syncer): the
+listed islands are no-sync samplers (learner 0 of 1, like a pair's samplers)
+and every other island is a synced trainer, learner k of K in island order
+(:func:`synced_group_learners`).
 
 This module is engine-neutral; the Miles mapping is in
 ``adapters.miles.buffer_rollout``.
@@ -98,11 +102,37 @@ def check_synced_trainers(args: Any, num_islands: int) -> None:
     if int(num_islands) < 2:
         raise ValueError("--rl-sample-role trainer without --rl-single-island-no-sync is a synced "
                          f"multi-island launch: it needs at least two islands (got {num_islands})")
-    if is_pair(args) or is_convertible_pool(args):
-        raise ValueError("synced trainers do not combine with --rl-island-sample-role or "
-                         "convertible nodes")
+    if is_convertible_pool(args):
+        raise ValueError("synced trainers do not combine with convertible nodes")
     if getattr(args, "tuning", "lora") != "lora":
         raise ValueError("synced trainers merge LoRA deltas: they need --tuning lora")
+    if is_synced_group(args):
+        check_synced_group(args, num_islands)
+
+
+def check_synced_group(args: Any, num_islands: int) -> None:
+    """Launch checks of a synced group (module doc): ``--rl-island-sample-role``
+    names only samplers, at least two trainers remain, and the samplers split the
+    trainers' rounds evenly; then every island's own role checks."""
+    listed = _listed_roles(args, num_islands)
+    if any(role != SAMPLER for role in listed.values()):
+        raise ValueError("--rl-island-sample-role with --rl-sample-role trainer names the sampler "
+                         f"islands only (every other island is a synced trainer); got {listed}")
+    trainers = len(synced_group_learners(args, num_islands))
+    if trainers < 2:
+        raise ValueError(f"a synced group needs at least two trainer islands (got {trainers}); "
+                         "one trainer with samplers is a pair (--rl-single-island-no-sync)")
+    samplers = len(listed)
+    if (trainers * int(getattr(args, "total_steps", 0) or 0)) % samplers:
+        raise ValueError(f"--total-steps {args.total_steps}: {samplers} sampler islands share the "
+                         f"rounds of {trainers} trainers; trainers x total steps must be a multiple "
+                         "of the sampler count")
+    if int(getattr(args, "external_learners", 0) or 0):
+        raise ValueError("a synced group does not take external learners")
+    if getattr(args, "rl_trainer_scheduler", None) not in (None, "off"):
+        raise ValueError("--rl-trainer-scheduler does not combine with a synced group")
+    for m in range(num_islands):
+        check_launch(island_args(args, m, num_islands))
 
 
 def check_sample_store(args: Any) -> None:
@@ -155,6 +185,14 @@ def island_roles(args: Any, num_islands: int) -> dict[int, str]:
     a malformed, out-of-range or repeated entry."""
     if is_convertible_pool(args):
         return {m: CONVERTIBLE for m in convertible_islands(args)}
+    roles = _listed_roles(args, num_islands)
+    if is_synced_group(args):
+        # the listed islands are samplers; every other island is a synced trainer
+        return {m: roles.get(m, TRAINER) for m in range(int(num_islands))}
+    return roles
+
+
+def _listed_roles(args: Any, num_islands: int) -> dict[int, str]:
     roles: dict[int, str] = {}
     for item in getattr(args, "rl_island_sample_role", None) or ():
         island, sep, role = str(item).partition(":")
@@ -173,8 +211,32 @@ def island_roles(args: Any, num_islands: int) -> dict[int, str]:
 
 def is_pair(args: Any) -> bool:
     """Whether the launch is a store-coupled group: one trainer island and one or
-    more sampler islands (``--rl-island-sample-role``; "pair" for short)."""
-    return bool(getattr(args, "rl_island_sample_role", None))
+    more sampler islands (``--rl-island-sample-role`` without a synced trainer
+    role; "pair" for short)."""
+    return bool(getattr(args, "rl_island_sample_role", None)) and not is_synced_group(args)
+
+
+def is_synced_group(args: Any) -> bool:
+    """S26 E9.4: one launch of synced trainers and their sampler islands
+    (``--rl-sample-role trainer`` with a syncer and ``--rl-island-sample-role
+    M:sampler``; module doc)."""
+    return bool(getattr(args, "rl_island_sample_role", None)) and is_synced_trainer(args)
+
+
+def synced_group_learners(args: Any, num_islands: int) -> dict[int, int]:
+    """{trainer island: learner id} of a synced group: the trainers in island order
+    are learners 0..K-1 (learner 0 releases the merged policy); {} otherwise."""
+    if not is_synced_group(args):
+        return {}
+    trainers = [m for m, role in sorted(island_roles(args, num_islands).items()) if role == TRAINER]
+    return {m: k for k, m in enumerate(trainers)}
+
+
+def syncer_learner_count(args: Any, num_islands: int) -> int:
+    """The learners the syncer waits for among the launch's islands: the trainers
+    of a synced group, every island otherwise (a no-sync launch has no syncer)."""
+    learners = synced_group_learners(args, num_islands)
+    return len(learners) if learners else int(num_islands)
 
 
 def sampler_islands(args: Any, num_islands: int) -> list[int]:
@@ -204,6 +266,8 @@ def island_args(args: Any, island: int, num_islands: int) -> Any:
     roles = island_roles(args, num_islands)
     if not roles:
         return args
+    if is_synced_group(args):
+        return _synced_group_island_args(args, island, num_islands, roles)
     out = copy.copy(args)
     out.rl_sample_role = roles[island]
     if out.rl_sample_role in (SAMPLER, TRAINER):
@@ -235,11 +299,52 @@ def island_args(args: Any, island: int, num_islands: int) -> Any:
     return out
 
 
-def island_learner(args: Any, island: int, num_learners: int) -> tuple[int, int]:
+def _synced_group_island_args(args: Any, island: int, num_islands: int, roles: dict[int, str]) -> Any:
+    """Island args of a synced group. A trainer keeps the synced args (its lane and
+    the sampler shards); a sampler becomes a pair-style no-sync sampler over the
+    same store: legacy scheduling (no syncer), its node name and data slot, and
+    its share of the trainers' rounds."""
+    from ...launch.syncer import _ISLAND_SCHEDULING_PARAMS
+
+    samplers = sampler_islands(args, num_islands)
+    out = copy.copy(args)
+    out.rl_island_sample_role = None  # the island is no group: its role is below
+    out.rl_sample_role = roles[island]
+    out.rl_buffer_shards = buffer_shards(args, num_islands)
+    out.rl_synced_trainers = len(synced_group_learners(args, num_islands))
+    if out.rl_sample_role == TRAINER:
+        out.rl_sampler_node = None
+        out.rl_sampler_data_slot = None
+        out.rl_sampler_max_backlog_rounds = None
+        out.rl_sampler_min_round_seconds = None
+        return out
+    out.rl_single_island_no_sync = True
+    out.rl_island_scheduling = None
+    for name, _flag in _ISLAND_SCHEDULING_PARAMS:
+        setattr(out, name, None)
+    out.rl_sampler_node = node_name(island)
+    out.rl_sampler_data_slot = (DataSlot(samplers.index(island), len(samplers)).env()
+                                if len(samplers) > 1 else None)
+    out.rl_sample_wait_s = None
+    out.total_steps = out.rl_synced_trainers * int(args.total_steps) // len(samplers)
+    if getattr(args, "rl_total_fragment_steps", None) is not None:
+        out.rl_total_fragment_steps = out.total_steps * int(getattr(args, "fragments", 1) or 1)
+    return out
+
+
+def island_learner(args: Any, island: int, num_learners: int,
+                   num_islands: int | None = None) -> tuple[int, int]:
     """``(learner id, number of learners)`` the island command carries. A pair
-    island is a one-learner no-sync island: (0, 1). The launcher keeps ``island``
-    for the cluster / Modal function name, the tape and the volumes."""
-    return (0, 1) if is_store_coupled(args) else (island, num_learners)
+    island is a one-learner no-sync island: (0, 1); so is a synced group's sampler,
+    and its trainers are learners 0..K-1 (:func:`synced_group_learners`). The
+    launcher keeps ``island`` for the cluster / Modal function name, the tape and
+    the volumes."""
+    if is_store_coupled(args):
+        return 0, 1
+    learners = synced_group_learners(args, num_learners if num_islands is None else num_islands)
+    if learners:
+        return (learners[island], len(learners)) if island in learners else (0, 1)
+    return island, num_learners
 
 
 def buffer_full_parameter(args: Any) -> bool:

From 3469d0ca0ef50560f7b0bf4366ad89419d0ca053 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 16:20:52 +0000
Subject: [PATCH 10/23] Reclaim marker keeps its single-node format; only a
 relayed marker names the rank

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 yeto/modal_runner.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/yeto/modal_runner.py b/yeto/modal_runner.py
index e5af4919..870414d3 100644
--- a/yeto/modal_runner.py
+++ b/yeto/modal_runner.py
@@ -995,7 +995,10 @@ def _write_reclaim_marker(path: str, num: int, clock, *, from_rank: int) -> None
     try:
         tmp = f"{path}.{os.getpid()}.{threading.get_ident()}.tmp"
         with open(tmp, "w", encoding="utf-8") as fh:
-            fh.write(json.dumps({"signal": int(num), "time": clock(), "rank": int(from_rank)}) + "\n")
+            record = {"signal": int(num), "time": clock()}
+            if from_rank:  # relayed from a rank>0 container (the driver names it)
+                record["rank"] = int(from_rank)
+            fh.write(json.dumps(record) + "\n")
         os.replace(tmp, path)
         print(f"[modal-island] signal {num} (rank {from_rank}): reclaim marker {path} written for the learner",
               flush=True)

From d1c91c1ab8d7d336b53d4933af38216688ff39ec Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 17:48:53 +0000
Subject: [PATCH 11/23] A merging trainer creates the sample-buffer index (verl
 pair with several samplers)

The verl buffer trainer opens its buffer with create_index=False. With named
shards no sampler writes index.jsonl, so the first merge failed with
FileNotFoundError (S26 E9 G1 on Modal). open_trainer_buffer now creates the
index whenever this trainer merges shards: it is the index's only writer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_verl_pair_launch.py | 22 ++++++++++++++++++++++
 yeto/rl/engine/sample_buffer.py       |  6 ++++--
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/tests/test_s26_e9_verl_pair_launch.py b/tests/test_s26_e9_verl_pair_launch.py
index ee6061da..f2b3f8d5 100644
--- a/tests/test_s26_e9_verl_pair_launch.py
+++ b/tests/test_s26_e9_verl_pair_launch.py
@@ -255,3 +255,25 @@ def test_synced_group_lists_samplers_only():
                                  rl_node_class=None)
     with pytest.raises(ValueError, match="sampler islands only"):
         sample_roles.check_synced_group(args, 3)
+
+
+def test_verl_trainer_buffer_merges_shards_without_a_sampler_index(tmp_path):
+    """G1 (e9-g1-d) root cause: the verl buffer trainer opens its buffer with
+    create_index=False; with named shards no sampler writes index.jsonl, so the
+    merging trainer must create it (it is the index's only writer)."""
+    from tests.test_rl_spot_sampler_replace import _cursor, _round
+    from yeto.rl.adapters.miles import buffer_rollout as br
+    from yeto.rl.engine.resume import CheckpointStore
+    from yeto.rl.engine.sample_buffer import FileSampleBuffer, open_trainer_buffer
+
+    writer = br.SamplerRoundWriter(FileSampleBuffer(CheckpointStore(tmp_path), batch_size=1,
+                                                    index="shards/island0.jsonl"), "island0", incarnation="a")
+    writer.write_round(0, _round(0, 3), _cursor(3))
+    assert not (tmp_path / "sample-buffer/index.jsonl").exists()
+    trainer = open_trainer_buffer(CheckpointStore(tmp_path), batch_size=1, create_index=False,
+                                  shards=["island0", "island1"])
+    assert len(trainer.select("t", 3)) == 3
+    assert (tmp_path / "sample-buffer/index.jsonl").exists()
+    # a plain (single-sampler) reader still never creates the index
+    reader = open_trainer_buffer(CheckpointStore(tmp_path / "plain"), batch_size=1, create_index=False)
+    assert not reader._merge and not (tmp_path / "plain/sample-buffer/index.jsonl").exists()
diff --git a/yeto/rl/engine/sample_buffer.py b/yeto/rl/engine/sample_buffer.py
index d5da89cd..538d63c3 100644
--- a/yeto/rl/engine/sample_buffer.py
+++ b/yeto/rl/engine/sample_buffer.py
@@ -361,10 +361,12 @@ def open_trainer_buffer(store: CheckpointStore | ObjectStore, *, batch_size: int
     store that shards (:func:`needs_shards`), or the named ``shards`` of several
     sampler islands on one shared directory (the data ends once every named
     shard ended), unless it is a synced trainer other than the publisher
-    (``merged_release.merges_shards``); ``lane``: its lane."""
+    (``merged_release.merges_shards``); ``lane``: its lane. A merging trainer
+    is the only writer of the index, so it creates the index even with
+    ``create_index=False`` (no sampler writes ``index.jsonl`` then)."""
     named = tuple(shards or ())
     merge = (needs_shards(store) or bool(named)) and merges_shards(lane)
-    return FileSampleBuffer(store, batch_size=batch_size, create_index=create_index, lane=lane,
+    return FileSampleBuffer(store, batch_size=batch_size, create_index=create_index or merge, lane=lane,
                             merge_shards=merge, expected_shards=named if merge and named else None, **kwargs)
 
 

From 18f2c946d067454a07a5c6b782cc83b4d818036d Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 19:05:58 +0000
Subject: [PATCH 12/23] verl buffer trainer releases the per-shard read
 positions

A sampler that writes its own buffer shard counts its backlog from the
release's buffer_shards. The verl publisher released only buffer_selected,
so on Modal (S26 E9 G1) both shard samplers stayed at their backlog cap and
the trainer timed out after four rounds. The release (and the release log)
now carries the read cursor per shard, as the Miles trainer does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_rl_verl_buffer_trainer.py  | 46 +++++++++++++++++++++++++--
 yeto/rl/adapters/verl/buffer_feed.py  |  6 ++++
 yeto/rl/adapters/verl/buffer_ports.py |  5 +--
 3 files changed, 53 insertions(+), 4 deletions(-)

diff --git a/tests/test_rl_verl_buffer_trainer.py b/tests/test_rl_verl_buffer_trainer.py
index 1b322d6c..4c938cd9 100644
--- a/tests/test_rl_verl_buffer_trainer.py
+++ b/tests/test_rl_verl_buffer_trainer.py
@@ -218,7 +218,7 @@ def yeto_call_workers(self, fn, tensors, reset):
         return [{"applied": len(tensors)}]
 
 
-def _trainer(tmp_path, store_dir, actor, *, rounds, required, base):
+def _trainer(tmp_path, store_dir, actor, *, rounds, required, base, buffer=None):
     from yeto.rl.adapters.verl.entry import verl_capabilities
     from yeto.rl.adapters.verl.fully_async_ports import FullyAsyncIsland, FullyAsyncTrainerGroup
     from yeto.rl.adapters.verl.ports_impl import VerlPolicyState
@@ -235,7 +235,7 @@ def _trainer(tmp_path, store_dir, actor, *, rounds, required, base):
     island.emit = lambda event, **f: tape.append({"event": event, **f})
     store = CheckpointStore(store_dir)
     rollout, publisher, placement = install_buffer_ports(
-        island, buffer=FileSampleBuffer(store, batch_size=1, create_index=False),
+        island, buffer=buffer or FileSampleBuffer(store, batch_size=1, create_index=False),
         releases=PolicyReleaseStore(store), shape=bf.RowShape(64, 16, 0), base_dir=base,
         tokenize=lambda text: [7, 8], poll_s=0.01, wait_s=30)
     profile = far.execution_profile_for(TOLERANT, 1, groups_per_round=required, samples_per_group=2, sync="none")
@@ -471,3 +471,45 @@ def test_a_synced_feed_reads_its_lane_translates_merged_versions_and_logs_each_r
     # a restarted island continues after the recorded cursor
     again = _synced_publisher(tmp_path, store, 1, [])[2].feed
     assert again.buffer.read_cursor == 6
+
+
+def test_two_shard_samplers_drain_their_backlog_through_the_verl_release(tmp_path):
+    """S26 E9 G1 (e9-g1-f) root cause: the verl trainer released without the per-shard
+    read positions, so a shard sampler never saw its backlog drain (stuck at the cap).
+    Two shard samplers with a 2-group cap now feed three rounds of 2 groups."""
+    from yeto.rl.engine.engine_sampler_entry import build_stores
+    from yeto.rl.engine.sample_buffer import open_trainer_buffer
+
+    store_dir = tmp_path / "store"
+    store = CheckpointStore(store_dir)
+    base, _weights = _base(tmp_path, dtype=torch.float32)
+    done, threads, events = threading.Event(), [], []
+    for sid in ("island0", "island1"):
+        releases, buffer = build_stores({"store": str(store_dir), "sampler_id": sid,
+                                         "buffer_shards": ["island0", "island1"]})
+        config = EngineSamplerConfig(sampler_id=sid, num_rollouts=40, max_backlog_groups=2,
+                                     sampling=SamplingParams(max_tokens=6, n=2), max_prompt_tokens=32, poll_s=0.01)
+        sampler = build_engine_sampler(
+            config, engine=FakeEngine(max_model_len=64), releases=releases, buffer=buffer,
+            emit=lambda n, _sid=sid, **f: events.append((_sid, n, f)),
+            prompts=lambda r, _sid=sid: [PromptItem(f"{_sid}-p{r}", f"prompt {r}", label="x")],
+            reward=lambda item, c: float(len(c.token_ids) % 2),
+            checks=PostLoadChecks(expected_expert_matrices=None, fixed_prompts=(), probe_pairs=(("Q", " 7"),)),
+            should_stop=done.is_set, sleep=lambda s: time.sleep(0.005))
+        threads.append(threading.Thread(target=sampler.run, daemon=True))
+        threads[-1].start()
+    trainer_buffer = open_trainer_buffer(store, batch_size=1, create_index=False, shards=["island0", "island1"])
+    driver, _island, _publisher = _trainer(tmp_path, store_dir, FakeBufferActor(), rounds=3, required=2,
+                                           base=base, buffer=trainer_buffer)
+    try:
+        driver.run()
+    finally:
+        done.set()
+        for t in threads:
+            t.join(timeout=10)
+    assert driver.rounds_completed == 3
+    releases = _lines(tmp_path / "out" / RELEASE_LOG.format(learner=0))
+    shards = [r["buffer_shards"] for r in releases if r["released"]]
+    assert all(set(s) <= {"island0", "island1"} and sum(s.values()) == r["buffer_selected"]
+               for s, r in zip(shards, [r for r in releases if r["released"]]))
+    assert PolicyReleaseStore(store).latest().buffer_shards == shards[-1]
diff --git a/yeto/rl/adapters/verl/buffer_feed.py b/yeto/rl/adapters/verl/buffer_feed.py
index cac0808a..f2562341 100644
--- a/yeto/rl/adapters/verl/buffer_feed.py
+++ b/yeto/rl/adapters/verl/buffer_feed.py
@@ -322,6 +322,12 @@ def read_cursor(self) -> int:
         samplers for their backlog cap)."""
         return int(self.buffer.read_cursor)
 
+    def read_shards(self) -> dict[str, int] | None:
+        """The read cursor per sampler shard (None without merged shards): a
+        sampler that writes its own shard counts its backlog from this
+        (``SamplerLoop.backlog``), not from the merged position."""
+        return self.buffer.shard_positions(self.buffer.read_cursor) or None
+
 
 ASSEMBLE_METHOD = "yeto_assemble"  # the rollout port's call after a round's collection
 
diff --git a/yeto/rl/adapters/verl/buffer_ports.py b/yeto/rl/adapters/verl/buffer_ports.py
index e8a7ba10..a13499be 100644
--- a/yeto/rl/adapters/verl/buffer_ports.py
+++ b/yeto/rl/adapters/verl/buffer_ports.py
@@ -140,15 +140,16 @@ def publish(self, state: Any) -> PublicationResult:
         merge: dict[str, Any] = {}
         release = None
         position = self.feed.read_cursor()
+        shards = self.feed.read_shards()
         released = self._release_version(state)
         if released is not None and not is_base_adapter(released, tensors):
             def write(directory: Path) -> None:
                 merge.update(self.merge(self.base_dir, tensors, directory))
 
             release = self.releases.release(released, digest, write, buffer_selected=position,
-                                            weights=FULL, origin=self._origin(state))
+                                            buffer_shards=shards, weights=FULL, origin=self._origin(state))
         record = {"policy_version": version, "param_version": param_version, "policy_hash": digest,
-                  "released": release is not None, "buffer_selected": position,
+                  "released": release is not None, "buffer_selected": position, "buffer_shards": shards,
                   "seconds": round(self.clock() - started, 3), "merge": merge or None,
                   "version_map": isl.vmap.to_dict()}
         if self.lane is not None:

From 2e125ed6329b7b4c5e2cff725b68bab9298515ad Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 19:21:30 +0000
Subject: [PATCH 13/23] Test: pass the shard trainer buffer by identity (an
 empty buffer is falsy)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_rl_verl_buffer_trainer.py | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/tests/test_rl_verl_buffer_trainer.py b/tests/test_rl_verl_buffer_trainer.py
index 4c938cd9..9863baef 100644
--- a/tests/test_rl_verl_buffer_trainer.py
+++ b/tests/test_rl_verl_buffer_trainer.py
@@ -234,8 +234,10 @@ def _trainer(tmp_path, store_dir, actor, *, rounds, required, base, buffer=None)
     tape = EventTape(tmp_path / "tape.jsonl", 0)
     island.emit = lambda event, **f: tape.append({"event": event, **f})
     store = CheckpointStore(store_dir)
+    if buffer is None:  # not ``or``: an empty FileSampleBuffer is falsy (len 0)
+        buffer = FileSampleBuffer(store, batch_size=1, create_index=False)
     rollout, publisher, placement = install_buffer_ports(
-        island, buffer=buffer or FileSampleBuffer(store, batch_size=1, create_index=False),
+        island, buffer=buffer,
         releases=PolicyReleaseStore(store), shape=bf.RowShape(64, 16, 0), base_dir=base,
         tokenize=lambda text: [7, 8], poll_s=0.01, wait_s=30)
     profile = far.execution_profile_for(TOLERANT, 1, groups_per_round=required, samples_per_group=2, sync="none")
@@ -496,13 +498,26 @@ def test_two_shard_samplers_drain_their_backlog_through_the_verl_release(tmp_pat
             reward=lambda item, c: float(len(c.token_ids) % 2),
             checks=PostLoadChecks(expected_expert_matrices=None, fixed_prompts=(), probe_pairs=(("Q", " 7"),)),
             should_stop=done.is_set, sleep=lambda s: time.sleep(0.005))
-        threads.append(threading.Thread(target=sampler.run, daemon=True))
+        def run(_sampler=sampler, _sid=sid):
+            try:
+                _sampler.run()
+            except BaseException as error:  # noqa: BLE001 - surfaced by the assert below
+                events.append((_sid, "crashed", {"error": repr(error)}))
+                raise
+
+        threads.append(threading.Thread(target=run, daemon=True))
         threads[-1].start()
     trainer_buffer = open_trainer_buffer(store, batch_size=1, create_index=False, shards=["island0", "island1"])
     driver, _island, _publisher = _trainer(tmp_path, store_dir, FakeBufferActor(), rounds=3, required=2,
                                            base=base, buffer=trainer_buffer)
     try:
         driver.run()
+    except Exception:
+        listing = sorted(str(p.relative_to(store_dir)) for p in (store_dir / "sample-buffer").rglob("*.jsonl"))
+        raise AssertionError(f"buffer {len(trainer_buffer)} shards {trainer_buffer.index.shard_names()} "
+                             f"files {listing}; "
+                             f"sampler events: {[(sid, n) for sid, n, _f in events][-20:]}; "
+                             f"crashes: {[f for _sid, n, f in events if n == 'crashed']}")
     finally:
         done.set()
         for t in threads:

From e3e94c189dcd0d0d3f8c550831d1753ca0024649 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:16:23 +0000
Subject: [PATCH 14/23] verl buffer trainer: the buffer's end ends the run
 FINISHED

On a buffer trainer the queue is the sample buffer. When the samplers ended
and a round could not be filled (groups passed over as older than
max_policy_age), FullyAsyncRolloutPool raised "rollouter ended the queue" and
the island left INFRA_FAILED (S26 E9 G1 on Modal, launcher rc=4). The buffer
ports now mark the pool so that end raises SampleBufferExhausted, which the
driver turns into rl_buffer_exhausted and a FINISHED run (as on Miles).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_rl_verl_buffer_trainer.py       | 25 ++++++++++++++++++++++
 yeto/rl/adapters/verl/buffer_ports.py      |  2 +-
 yeto/rl/adapters/verl/fully_async_ports.py | 14 +++++++++++-
 3 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/tests/test_rl_verl_buffer_trainer.py b/tests/test_rl_verl_buffer_trainer.py
index 9863baef..b15ba1e5 100644
--- a/tests/test_rl_verl_buffer_trainer.py
+++ b/tests/test_rl_verl_buffer_trainer.py
@@ -528,3 +528,28 @@ def run(_sampler=sampler, _sid=sid):
     assert all(set(s) <= {"island0", "island1"} and sum(s.values()) == r["buffer_selected"]
                for s, r in zip(shards, [r for r in releases if r["released"]]))
     assert PolicyReleaseStore(store).latest().buffer_shards == shards[-1]
+
+
+def test_verl_buffer_trainer_ends_finished_when_the_samplers_end_early(tmp_path):
+    """S26 E9 G1 (e9-g1-h): the buffer ended with groups passed over as too old, so
+    the trainer could not fill its last round. On verl that was "rollouter ended
+    the queue" (INFRA_FAILED); it is the buffer's end: the run ends FINISHED."""
+    store_dir = tmp_path / "store"
+    store = CheckpointStore(store_dir)
+    base, _weights = _base(tmp_path, dtype=torch.float32)
+    engine = FakeEngine(max_model_len=64)
+    config = EngineSamplerConfig(sampler_id="island0", num_rollouts=4, max_backlog_groups=8,
+                                 sampling=SamplingParams(max_tokens=6, n=2), max_prompt_tokens=32, poll_s=0.01)
+    sampler = build_engine_sampler(
+        config, engine=engine, releases=PolicyReleaseStore(store), buffer=FileSampleBuffer(store, batch_size=1),
+        emit=lambda n, **f: None,
+        prompts=lambda r: [PromptItem(f"p{r}", f"prompt {r}", label="x")], reward=lambda item, c: float(len(c.token_ids) % 2),
+        checks=PostLoadChecks(expected_expert_matrices=None, fixed_prompts=(), probe_pairs=(("Q", " 7"),)),
+        should_stop=lambda: False, sleep=lambda s: time.sleep(0.005))
+    sampler.run()  # 4 groups, then the data end
+    driver, _island, _publisher = _trainer(tmp_path, store_dir, FakeBufferActor(), rounds=3, required=2, base=base)
+    driver.run()
+    assert driver.rounds_completed == 2
+    events = _lines(tmp_path / "tape.jsonl")
+    exhausted = [e for e in events if e["event"] == "rl_buffer_exhausted"]
+    assert [e["rollout_id"] for e in exhausted] == [2] and "SampleBufferExhausted" in exhausted[0]["error"]
diff --git a/yeto/rl/adapters/verl/buffer_ports.py b/yeto/rl/adapters/verl/buffer_ports.py
index a13499be..b401ef75 100644
--- a/yeto/rl/adapters/verl/buffer_ports.py
+++ b/yeto/rl/adapters/verl/buffer_ports.py
@@ -213,4 +213,4 @@ def record(fields: dict[str, Any]) -> None:
     island.call = BufferCall(feed, actor_call, round_id=lambda: int(island.published[0]))
     island.start_rollouter = None  # no rollouter: the samplers run elsewhere
     publisher = BufferReleasePublisher(island, releases, feed, base_dir=base_dir, lane=lane)
-    return FullyAsyncRolloutPool(island), publisher, BufferPlacement()
+    return FullyAsyncRolloutPool(island, queue_end_is_buffer_end=True), publisher, BufferPlacement()
diff --git a/yeto/rl/adapters/verl/fully_async_ports.py b/yeto/rl/adapters/verl/fully_async_ports.py
index 1526d389..5a50aa8b 100644
--- a/yeto/rl/adapters/verl/fully_async_ports.py
+++ b/yeto/rl/adapters/verl/fully_async_ports.py
@@ -100,9 +100,15 @@ def append_jsonl(self, name: str, record: dict) -> None:
 
 
 class FullyAsyncRolloutPool:
-    def __init__(self, island: FullyAsyncIsland, *, max_pulls_factor: int = 8):
+    def __init__(self, island: FullyAsyncIsland, *, max_pulls_factor: int = 8,
+                 queue_end_is_buffer_end: bool = False):
+        """``queue_end_is_buffer_end``: the queue is the sample buffer (a buffer
+        trainer): its end is the samplers' data end, so a round it cannot fill
+        raises :class:`~yeto.rl.engine.buffer_payload.SampleBufferExhausted` and
+        the run ends FINISHED (S26 E9.3), not a failure."""
         self.island = island
         self.max_pulls = max_pulls_factor * island.required
+        self.queue_end_is_buffer_end = bool(queue_end_is_buffer_end)
         self._cursor = FullyAsyncDataCursor(island.seek_rollouter)
 
     def data_cursor(self) -> dict[str, int]:
@@ -132,6 +138,12 @@ def generate(self, rollout_id: int, *, expected_policy_version: str | None = Non
                                    f"{len(collector.kept)}/{isl.required} within the policy-age limit")
             meta = isl.call("yeto_pull_sample")
             if meta is None:
+                if self.queue_end_is_buffer_end:
+                    from yeto.rl.engine.buffer_payload import SampleBufferExhausted
+
+                    raise SampleBufferExhausted(
+                        f"rollout {rollout_id}: the sample buffer ended with {len(collector.kept)}/"
+                        f"{isl.required} trainable groups for this round")
                 raise RuntimeError(f"rollout {rollout_id}: rollouter ended the queue")
             pulled += 1
             self._cursor.consume(1)

From 621cac631d5654d982a501c2e0c3d97c8d4fd89e Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:36:04 +0000
Subject: [PATCH 15/23] Engine sampler island: a finished run ends its tape
 with rl_learner_finalized

The launcher requires every island tape to end with rl_learner_finalized; a
verl pair's sampler islands run the engine sampler, whose tape never had it,
so a run whose islands all succeeded exited 3 (S26 E9 G1 on Modal). A
finished incarnation now writes it; a reclaimed one does not (the next
incarnation continues the island).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s25_g1c_sampler_resume.py   | 5 +++++
 yeto/rl/engine/engine_sampler_entry.py | 9 ++++++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/tests/test_s25_g1c_sampler_resume.py b/tests/test_s25_g1c_sampler_resume.py
index 88ad0fa0..d97f9cfe 100644
--- a/tests/test_s25_g1c_sampler_resume.py
+++ b/tests/test_s25_g1c_sampler_resume.py
@@ -150,6 +150,8 @@ def test_reclaim_marker_stops_writes_and_leaves_preempted(tmp_path):
     [tape] = (tmp_path / "tape").glob("events.*.jsonl")
     leave = [e for e in _tape(tape) if e["event"] == "rl_sampler_leave"]
     assert len(leave) == 1 and leave[0]["reason"] == "PREEMPTED"
+    # the next incarnation continues: this tape is not complete (S26 E9)
+    assert not any(e["event"] == "rl_learner_finalized" for e in _tape(tape))
 
 
 def test_caller_stop_ends_the_island_finished_and_on_event_sees_the_tape(tmp_path):
@@ -166,6 +168,9 @@ def test_caller_stop_ends_the_island_finished_and_on_event_sees_the_tape(tmp_pat
     [tape] = (tmp_path / "tape").glob("events.*.jsonl")
     assert [e["event"] for e in _tape(tape)] == [e for e, _ in seen]
     assert [f["reason"] for e, f in seen if e == "rl_sampler_leave"] == ["FINISHED"]
+    # S26 E9 G1 (e9-g1-i, launcher exit 3): a finished island's tape ends with the
+    # record the launcher requires of every island tape
+    assert seen[-1] == ("rl_learner_finalized", {"rounds": 1})
 
 
 def test_hold_after_reclaim_only_when_the_marker_is_there(tmp_path):
diff --git a/yeto/rl/engine/engine_sampler_entry.py b/yeto/rl/engine/engine_sampler_entry.py
index 884aabb4..bc33c53c 100644
--- a/yeto/rl/engine/engine_sampler_entry.py
+++ b/yeto/rl/engine/engine_sampler_entry.py
@@ -337,8 +337,15 @@ def resource_sampler(sink: Callable[..., None]) -> Any:
         membership.join(tape=str(tape), latest_release=None if latest is None else
                         {"seq": latest.seq, "policy_version": latest.version})
         rounds = 0 if buffer.data_ended else island.run()
-        leave(LeaveReason.PREEMPTED if reclaimed() else LeaveReason.FINISHED, rounds=rounds,
+        preempted = reclaimed()
+        leave(LeaveReason.PREEMPTED if preempted else LeaveReason.FINISHED, rounds=rounds,
               dropped_groups=island.round.dropped_groups)
+        if not preempted:
+            from yeto.rl.event_echo import FINALIZED_EVENT  # noqa: PLC0415
+
+            # a launcher island's complete tape ends with this record (yeto.launch.tapes);
+            # a reclaimed incarnation's tape stays open: the next incarnation continues
+            emit(FINALIZED_EVENT, rounds=rounds)
         return rounds
     except BaseException as error:
         try:

From 1c23a60f2c4255dfdbf815772a352777849d3024 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 20:51:56 +0000
Subject: [PATCH 16/23] Engine sampler tape records carry the launcher island
 id

The launcher completes a Modal island's event tape from the island's tape
file and accepts only records with island_id. The verl pair's sampler islands
write engine sampler records (sampler_id only), so every record, the new
rl_learner_finalized included, was discarded and the run exited 3 although
all islands succeeded (S26 E9 G1). The verl sampler spec now names the
island (island_id = learner id) and the tape writer adds it to each record.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s25_g1c_sampler_resume.py   | 15 +++++++++++++++
 tests/test_s26_e9_verl_pair_launch.py  |  1 +
 yeto/rl/adapters/verl/sampler_entry.py |  2 ++
 yeto/rl/engine/engine_sampler_entry.py | 10 +++++++---
 4 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/tests/test_s25_g1c_sampler_resume.py b/tests/test_s25_g1c_sampler_resume.py
index d97f9cfe..e29adaaa 100644
--- a/tests/test_s25_g1c_sampler_resume.py
+++ b/tests/test_s25_g1c_sampler_resume.py
@@ -181,3 +181,18 @@ def test_hold_after_reclaim_only_when_the_marker_is_there(tmp_path):
     assert entry.hold_after_reclaim(env, hold_s=5.0, sleep=slept.append) is False and slept == []
     (tmp_path / "marker").write_text("{}")
     assert entry.hold_after_reclaim(env, hold_s=5.0, sleep=slept.append) is True and slept == [5.0]
+
+
+def test_a_launcher_island_tape_is_recovered_complete(tmp_path):
+    """S26 E9 G1 (e9-g1-j, exit 3): with the spec's island_id every record carries
+    it, so the launcher's tape recovery accepts the file and sees the finalized
+    record; without it the records are discarded as not island tape lines."""
+    from yeto.rl.event_echo import TapeCollector
+
+    spec = {**_spec(tmp_path, rounds=1), "island_id": 0}
+    assert entry.run(spec, resource_sampler=lambda emit: None, incarnation="aaaa0001") == 1
+    [tape] = (tmp_path / "tape").glob("events.*.jsonl")
+    assert all(r["island_id"] == 0 for r in _tape(tape))
+    collector = TapeCollector(tmp_path / "events" / "l0.jsonl", fresh=False)
+    assert collector.recover_from_file(tape) is True
+    assert collector.discarded == 0 and collector.count == len(_tape(tape))
diff --git a/tests/test_s26_e9_verl_pair_launch.py b/tests/test_s26_e9_verl_pair_launch.py
index f2b3f8d5..bac2b679 100644
--- a/tests/test_s26_e9_verl_pair_launch.py
+++ b/tests/test_s26_e9_verl_pair_launch.py
@@ -109,6 +109,7 @@ def test_one_launch_gives_one_sampler_and_one_trainer(monkeypatch):
     spec = sampler_entry.sampler_spec(sampler, model_path="/m", prompts_path="/p.jsonl", card_model="A10G",
                                       engine_version="0.x", event_tape="/t/events.jsonl", python="python3")
     assert spec["sampler_id"] == "island0" and spec["store"] == sampler.rl_resume_store
+    assert spec["island_id"] == 0  # the launcher reads the sampler tape as island tape
     assert spec["engine"]["adapter"] == "vllm-server" and spec["num_rollouts"] == 4
     assert spec["max_backlog_groups"] == 4 * sample_roles.DEFAULT_MAX_BACKLOG_ROUNDS
     assert spec["reward"] == "yeto.rl.gsm8k_reward:score" and "buffer_shards" not in spec
diff --git a/yeto/rl/adapters/verl/sampler_entry.py b/yeto/rl/adapters/verl/sampler_entry.py
index 1ff3de3f..4133d500 100644
--- a/yeto/rl/adapters/verl/sampler_entry.py
+++ b/yeto/rl/adapters/verl/sampler_entry.py
@@ -104,6 +104,8 @@ def sampler_spec(args: Any, *, model_path: str, prompts_path: str, card_model: s
         "reward": sampler_reward(args.reward_function), "reward_kind": "miles",
         "checks": {"expected_expert_matrices": None, "fixed_prompts": []},
         "event_tape": str(event_tape),
+        # the launcher reads this tape as the island's tape (records need island_id)
+        "island_id": int(getattr(args, "learner_id", 0) or 0),
     }
     if getattr(args, "rl_sampler_data_slot", None):
         spec["prompts"]["data_slot"] = str(args.rl_sampler_data_slot)
diff --git a/yeto/rl/engine/engine_sampler_entry.py b/yeto/rl/engine/engine_sampler_entry.py
index bc33c53c..736fb5e4 100644
--- a/yeto/rl/engine/engine_sampler_entry.py
+++ b/yeto/rl/engine/engine_sampler_entry.py
@@ -235,14 +235,18 @@ def incarnation_tape(path: str | Path, incarnation: str) -> Path:
     return tape.with_name(f"{tape.stem}.{incarnation}{tape.suffix or '.jsonl'}")
 
 
-def tape_writer(path: str | Path, sampler_id: str) -> Callable[..., None]:
+def tape_writer(path: str | Path, sampler_id: str, island_id: int | None = None) -> Callable[..., None]:
+    """``island_id``: the launcher island this sampler runs as; its records then
+    carry it, so the launcher accepts the file as the island's event tape
+    (``yeto.rl.event_echo.REQUIRED_KEYS``)."""
     from yeto.rl.event_echo import append_record  # noqa: PLC0415
 
     tape = Path(path).expanduser()
     tape.parent.mkdir(parents=True, exist_ok=True)
+    head = {"sampler_id": sampler_id} if island_id is None else {"island_id": int(island_id), "sampler_id": sampler_id}
 
     def emit(event: str, **fields: Any) -> None:
-        append_record(tape, {"sampler_id": sampler_id, "time_unix": time.time(), "event": event, **fields})
+        append_record(tape, {**head, "time_unix": time.time(), "event": event, **fields})
 
     return emit
 
@@ -292,7 +296,7 @@ def run(spec: Mapping[str, Any], *, environ: Mapping[str, str] | None = None,
     config = island_config(spec)
     incarnation = incarnation or new_incarnation()
     tape = incarnation_tape(_require(spec, "event_tape"), incarnation)
-    write = tape_writer(tape, config.sampler_id)
+    write = tape_writer(tape, config.sampler_id, spec.get("island_id"))
 
     def emit(event: str, **fields: Any) -> None:
         write(event, **fields)

From 7ee7aab6266c7a25d42f2917077ec40696e0ba91 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:04:46 +0000
Subject: [PATCH 17/23] fully_async round cuts: the rollout pool exports no
 in-flight work

With --rl-max-policy-age > 0 a round cut asks the rollout pool for its
in-flight work. FullyAsyncRolloutPool had no export_in_flight, so every cut
of a fully_async verl island was refused (RebuildRefused; S26 E9 G2 on
Modal: rl_round_cut ok=false for each round). A round keeps or drops every
group it pulls, so nothing pulled is in flight at the cut; the groups still
queued in the rollouter are generated again after a resume from the data
cursor. The export is now empty and the cut is written.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_verl_fully_async_cut.py  | 23 ++++++++++++++++++++++
 yeto/rl/adapters/verl/fully_async_ports.py |  8 ++++++++
 2 files changed, 31 insertions(+)

diff --git a/tests/test_s26_e9_verl_fully_async_cut.py b/tests/test_s26_e9_verl_fully_async_cut.py
index 37a8351e..288d88db 100644
--- a/tests/test_s26_e9_verl_fully_async_cut.py
+++ b/tests/test_s26_e9_verl_fully_async_cut.py
@@ -126,3 +126,26 @@ def test_trainer_group_without_cuts_refuses_to_cut():
     port = FullyAsyncTrainerGroup(SimpleNamespace(call_workers=lambda fn, *a: [], optimizer_steps_per_round=None))
     with pytest.raises(RuntimeError, match="without round cuts"):
         port._cuts()
+
+
+def test_a_fully_async_round_cut_takes_the_pool_with_a_policy_age(tmp_path):
+    """S26 E9 G2 (e9-g2-b): with --rl-max-policy-age > 0 the cut asks the rollout
+    pool for its in-flight work; the fully_async pool had no export, so every cut
+    was refused (RebuildRefused). It now exports nothing (queued groups are
+    generated again after a resume) and the cut context is built."""
+    from yeto.rl.adapters.verl.fully_async_ports import FullyAsyncRolloutPool
+    from yeto.rl.engine.algorithm import AlgorithmSpec
+    from yeto.rl.engine.round_cut import CutSource
+
+    island = SimpleNamespace(required=2, rollouter_started=True, seek_rollouter=None,
+                             emit=lambda event, **f: None)
+    pool = FullyAsyncRolloutPool(island)
+    pool._cursor.consume(5)
+    state = SimpleNamespace(policy_version=3, policy_tensor_hash=lambda: "h" * 64)
+    driver = SimpleNamespace(published_state=state, published_version=3, local_step=3,
+                             profile=SimpleNamespace(max_policy_age=2), at_safe_point=True, expected_token="yeto:3:h")
+    source = CutSource(driver=driver, trainer=None, rollout=pool, ledger=None, algorithm=AlgorithmSpec(),
+                       backend_fingerprint="sha256:" + "0" * 64, cut_root="", global_batch_size=1)
+    context = source.context("r000003-x")
+    assert context.data == {"sample_offset": 5, "buffer_length": 0}
+    assert tuple(context.in_flight) == () and context.ledger["max_policy_age"] == 2
diff --git a/yeto/rl/adapters/verl/fully_async_ports.py b/yeto/rl/adapters/verl/fully_async_ports.py
index 5a50aa8b..c41fdeed 100644
--- a/yeto/rl/adapters/verl/fully_async_ports.py
+++ b/yeto/rl/adapters/verl/fully_async_ports.py
@@ -115,6 +115,14 @@ def data_cursor(self) -> dict[str, int]:
         """Prompts the rounds took from the queue (kept or discarded; .fully_async_cut)."""
         return self._cursor.cursor()
 
+    def export_in_flight(self) -> dict[str, Any]:
+        """A round cut's in-flight work (``round_cut.CutSource``): none is carried.
+        Every group a round pulled is kept for that round or dropped, so the
+        driver holds no pulled group at the cut; the groups still queued in the
+        rollouter are generated again after a resume, from the data cursor
+        (:mod:`.fully_async_cut`)."""
+        return {"entries": [], "buffer_groups": 0}
+
     def seek_data_cursor(self, cursor) -> dict[str, int]:
         self._cursor.started = self.island.rollouter_started
         landed = self._cursor.seek(cursor)

From af35378b2a28eefbbbdcaebcff95b1ec2e079f5c Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Wed, 21 Oct 2026 00:39:55 +0000
Subject: [PATCH 18/23] verl sync island trains on every card of its container;
 multi-card Modal verl islands default NCCL_SHM_DISABLE=1

The sync path pinned trainer.n_gpus_per_node=1, so a 2-card container trained
on one rank (S26 E9 e9-g3-a). The island now takes the card count from its
island-local Ray. A 2-card verl island on Modal failed attaching NCCL shared
memory (e9-g2-a); the launcher sets NCCL_SHM_DISABLE=1 for multi-card verl
Modal islands unless --modal-env sets it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_rl_verl_adapter.py         |  2 +-
 tests/test_s26_e9_verl_multigpu.py    | 64 +++++++++++++++++++++++++++
 yeto/launch/modal_islands.py          | 15 +++++++
 yeto/rl/adapters/verl/config.py       |  4 +-
 yeto/rl/adapters/verl/island_entry.py | 14 +++++-
 5 files changed, 95 insertions(+), 4 deletions(-)
 create mode 100644 tests/test_s26_e9_verl_multigpu.py

diff --git a/tests/test_rl_verl_adapter.py b/tests/test_rl_verl_adapter.py
index 96c58845..57a5677e 100644
--- a/tests/test_rl_verl_adapter.py
+++ b/tests/test_rl_verl_adapter.py
@@ -94,7 +94,7 @@ def test_verl_run_config_rules_refuse_multi_gpu_and_megatron_options():
     (dict(top_p=0.9), "top_p"),
     (dict(top_k=50), "top_p/top_k"),
     (dict(temperature=0.7), "温度"),
-    (dict(n_gpus=2), "1 张卡"),
+    (dict(n_gpus=0), "n_gpus 必须 >= 1"),
 ])
 def test_config_rules_refuse(kw, match):
     with pytest.raises(vconf.VerlConfigError, match=match):
diff --git a/tests/test_s26_e9_verl_multigpu.py b/tests/test_s26_e9_verl_multigpu.py
new file mode 100644
index 00000000..b100341c
--- /dev/null
+++ b/tests/test_s26_e9_verl_multigpu.py
@@ -0,0 +1,64 @@
+"""S26 E9 G3: a verl sync island uses every card of its container; a multi-card
+verl island on Modal runs NCCL with the shared-memory transport off."""
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from yeto.gpu_spec import parse_gpu_spec
+from yeto.launch import modal_islands
+from yeto.rl.adapters.verl import config as vconf
+from yeto.rl.adapters.verl.island_entry import island_gpus
+
+
+def _run(**kw) -> vconf.VerlRunConfig:
+    return vconf.VerlRunConfig(model_path="/m", train_file="/t", val_file="/v", out_dir="/o", **kw)
+
+
+def test_two_card_sync_island_trains_on_both_ranks():
+    overrides = vconf.build_overrides(_run(n_gpus=2))
+    assert "trainer.n_gpus_per_node=2" in overrides and "trainer.nnodes=1" in overrides
+
+
+def test_zero_cards_is_refused():
+    with pytest.raises(vconf.VerlConfigError, match="n_gpus"):
+        vconf.validate(_run(n_gpus=0))
+
+
+@pytest.mark.parametrize("info, want", [
+    ({"before": {"CPU": 32.0, "GPU": 2.0}}, 2),
+    ({"before": {"CPU": 8.0, "GPU": 2.0}, "after": {"CPU": 32.0, "GPU": 2.0}}, 2),
+    ({"before": {"CPU": 32.0}}, 1),          # no GPU resource reported
+    ({"skipped": "no RAY_ADDRESS"}, 1),      # no island-local Ray
+])
+def test_island_gpus_reads_the_island_ray(info, want):
+    assert island_gpus(info) == want
+
+
+@pytest.mark.parametrize("backend, gpu, want", [
+    ("verl", "modal:2xa10g", True),
+    ("verl", "modal:1xa10g", False),
+    ("miles", "modal:2xa10g", False),
+    (None, "modal:2xa10g", False),           # default backend is Miles
+])
+def test_nccl_shm_off_only_for_multi_card_verl(backend, gpu, want):
+    (spec,) = parse_gpu_spec(gpu)
+    assert modal_islands.verl_needs_nccl_shm_off(SimpleNamespace(rl_backend=backend), spec) is want
+
+
+@pytest.mark.parametrize("extra, want", [
+    ((), "1"),
+    (("--modal-env", "NCCL_SHM_DISABLE=0"), "0"),  # an explicit --modal-env wins
+])
+def test_modal_island_config_carries_the_default(monkeypatch, tmp_path, extra, want):
+    from yeto import cli
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+    args = cli.parse_args(["--training-mode", "rl", "--rl-backend", "verl", "--gpu", "modal:2xa10g",
+                           "--cluster-prefix", "e9g3", "--model", "Qwen/Qwen3-0.6B", "--data", "d", *extra])
+    args.rl_image = "verl-build:" + "a" * 40  # what resolve_default_rl_image sets for verl
+    (spec,) = parse_gpu_spec(args.gpu)
+    task = SimpleNamespace(envs={}, secrets={}, file_mounts={}, run="true", setup="")
+    cfg = modal_islands.build_modal_island_config(args, spec, 0, task, "none")
+    assert cfg.envs["NCCL_SHM_DISABLE"] == want
diff --git a/yeto/launch/modal_islands.py b/yeto/launch/modal_islands.py
index 74649a6d..89736be2 100644
--- a/yeto/launch/modal_islands.py
+++ b/yeto/launch/modal_islands.py
@@ -25,6 +25,19 @@
 from .fleet import TEARDOWN_UNVERIFIED_EXIT
 
 
+def verl_needs_nccl_shm_off(args, spec: ClusterSpec) -> bool:
+    """A verl island with several cards in one Modal container runs NCCL with
+    its shared-memory transport off.
+
+    S26 E9 e9-g2-a: on a 2-card Modal container verl's NCCL checkpoint engine
+    failed attaching ``/dev/shm/nccl-*`` ("No such file or directory", NCCL
+    system error); the same run with ``NCCL_SHM_DISABLE=1`` passed (e9-g2-d/e).
+    NCCL then uses P2P/sockets between the two local ranks. Miles islands are
+    not changed (no failure seen there)."""
+    backend = getattr(args, "rl_backend", None) or "miles"
+    return backend == "verl" and int(spec.gpus_per_node or 1) > 1
+
+
 def build_modal_island_config(args, spec: ClusterSpec, learner_id: int, task, syncer_addr: str):
     """Turn the sky task the factory built for this island into the Modal
     island config: same run script, same envs (syncer address swapped for
@@ -50,6 +63,8 @@ def build_modal_island_config(args, spec: ClusterSpec, learner_id: int, task, sy
         # The critic syncer shares the actor syncer's host: swap it too, or a
         # Modal island behind --syncer-public-addr dials the private address.
         envs["CRITIC_SYNCER_ADDR"] = critic_syncer_address(syncer_addr)
+    if rl and verl_needs_nccl_shm_off(args, spec):
+        envs.setdefault("NCCL_SHM_DISABLE", "1")  # --modal-env below still overrides it
     for item in getattr(args, "modal_env", None) or []:
         key, sep, value = str(item).partition("=")
         if not sep or not key:
diff --git a/yeto/rl/adapters/verl/config.py b/yeto/rl/adapters/verl/config.py
index 8c0b6a81..d217ddac 100644
--- a/yeto/rl/adapters/verl/config.py
+++ b/yeto/rl/adapters/verl/config.py
@@ -111,8 +111,8 @@ def validate(cfg: VerlRunConfig, *, expected_commit: str = VERL_COMMIT) -> None:
             "确需如此请显式 allow_sampling_shift")
     if cfg.groups_per_round <= 0 or cfg.samples_per_group <= 0 or cfg.total_rounds <= 0:
         raise VerlConfigError("groups_per_round / samples_per_group / total_rounds 必须为正")
-    if cfg.n_gpus != 1:
-        raise VerlConfigError("verl 后端第一版每岛只支持 1 张卡（V1/V2 范围）")
+    if cfg.n_gpus < 1:
+        raise VerlConfigError(f"n_gpus 必须 >= 1（单节点岛的卡数），得到 {cfg.n_gpus}")
     if cfg.model_dtype not in ("fp32", "bf16"):
         raise VerlConfigError(f"model_dtype 必须是 fp32 或 bf16，得到 {cfg.model_dtype!r}")
 
diff --git a/yeto/rl/adapters/verl/island_entry.py b/yeto/rl/adapters/verl/island_entry.py
index aaa92711..8891e346 100644
--- a/yeto/rl/adapters/verl/island_entry.py
+++ b/yeto/rl/adapters/verl/island_entry.py
@@ -24,8 +24,10 @@
 import subprocess
 import sys
 import time
+from collections.abc import Mapping
 from pathlib import Path
 from types import SimpleNamespace
+from typing import Any
 
 from . import config as vconf
 from . import run_config_rules
@@ -237,6 +239,16 @@ def _ray_resources(address: str) -> dict:
     return {}
 
 
+def island_gpus(ray_info: Mapping[str, Any]) -> int:
+    """GPUs of this single-node island: the island-local Ray's ``GPU`` resource
+    (the launcher starts it with every card of the container), else 1.
+
+    S26 E9 G3: the sync island used ``n_gpus=1`` always, so a 2-card container
+    trained on one rank (e9-g3-a); every card now joins the FSDP2 group."""
+    resources = ray_info.get("after") or ray_info.get("before") or {}
+    return max(1, int(resources.get("GPU", 0)))
+
+
 def ensure_ray_cpus(min_cpus: int = MIN_RAY_CPUS) -> dict:
     """verl needs more Ray CPU slots than a small container reports.
 
@@ -336,7 +348,7 @@ def main(argv=None) -> int:
         gpu_memory_utilization=float(os.environ.get("YETO_VERL_GPU_MEM", "0.5")),
         reward_path=str(Path(__file__).with_name("reward_fn.py")),
         reward_name=function_for(args.reward_function), chat_template_kwargs=chat,
-        experiment_name=f"yeto-verl-{lid}")
+        n_gpus=island_gpus(ray_info), experiment_name=f"yeto-verl-{lid}")
     overrides = vconf.build_overrides(run) + [
         "actor_rollout_ref.rollout.agent.num_workers=2",
         "reward.num_workers=2",

From f6bdc9f34262a3fdebbd6921be1d148b96883eaf Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Wed, 21 Oct 2026 00:42:45 +0000
Subject: [PATCH 19/23] Miles sampler: forward the data-slot env to the Ray
 rollout workers; samples record their data row

e9-g4-a: both Miles samplers drew the same 16 prompts (prompt text overlap
16 of 16/24). DATA_SLOT_ENV was set in the island process but missing from
ISLAND_ENVS, so the rollout worker never split its data source. Each kept row
now also records its index in the unsplit data as metadata["yeto_data_row"],
which reaches the sample buffer payload.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_data_slots.py          | 24 ++++++++++++++++++++++++
 yeto/rl/adapters/miles/buffer_rollout.py | 13 +++++++++++--
 2 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/tests/test_s26_e9_data_slots.py b/tests/test_s26_e9_data_slots.py
index 8609d4d8..d9f09bc5 100644
--- a/tests/test_s26_e9_data_slots.py
+++ b/tests/test_s26_e9_data_slots.py
@@ -134,6 +134,18 @@ def test_miles_data_source_slots_are_disjoint(shuffle):
     assert not drawn[0] & drawn[1] and drawn[0] | drawn[1] == set(rows)
 
 
+@pytest.mark.parametrize("shuffle", [False, True])
+def test_miles_slot_rows_record_their_unsplit_row(shuffle):
+    """S26 E9 G4: the buffer payload shows which data row a sampler drew."""
+    from yeto.rl.adapters.miles.buffer_rollout import DATA_ROW_KEY, apply_data_slot
+
+    rows = [SimpleNamespace(prompt=f"q{r}", metadata={"label": r}) for r in range(9)]
+    source = _source(rows, shuffle)
+    assert apply_data_slot(source, DataSlot(1, 3), shuffle=shuffle) == 3
+    kept = sorted(s.metadata[DATA_ROW_KEY] for s in source.dataset.samples)
+    assert kept == [1, 4, 7] and all(s.metadata["label"] == s.metadata[DATA_ROW_KEY] for s in rows)
+
+
 def test_miles_data_slot_refuses_after_the_first_draw():
     from yeto.rl.adapters.miles.buffer_rollout import apply_data_slot
 
@@ -155,6 +167,18 @@ def test_island_env_exports_the_slot_for_a_sampler_only():
         br.island_env("trainer", store_root="/s", max_policy_age=2, data_slot="0/2")
 
 
+def test_every_island_env_reaches_the_ray_workers():
+    """S26 E9 G4 (e9-g4-a): the slot env was set in the island process but not
+    forwarded to the Ray rollout worker, so both samplers drew the same prompts."""
+    from yeto.rl.adapters.miles import buffer_rollout as br
+
+    envs = [br.island_env("sampler", store_root="/s", sampler_id="island0", shards=["island0", "island1"],
+                          data_slot="0/2"),
+            br.island_env("trainer", store_root="/s", max_policy_age=2, wait_s=9.0, lane=br.BufferLane(1, 2),
+                          shards=["island0", "island1"])]
+    assert {k for env in envs for k in env} <= set(br.ISLAND_ENVS)
+
+
 # ------------------------------------------------------- exhausted buffer end
 def test_is_buffer_exhausted_follows_wrappers():
     inner = SampleBufferExhausted("ended")
diff --git a/yeto/rl/adapters/miles/buffer_rollout.py b/yeto/rl/adapters/miles/buffer_rollout.py
index 345f90db..4c701921 100644
--- a/yeto/rl/adapters/miles/buffer_rollout.py
+++ b/yeto/rl/adapters/miles/buffer_rollout.py
@@ -89,7 +89,7 @@
 # the rollout functions run in Ray workers, which inherit the raylet's environment:
 # connect_island_ray forwards these to every worker
 ISLAND_ENVS = (BUFFER_ROOT_ENV, SAMPLER_ID_ENV, WAIT_ENV, POLL_ENV, MAX_POLICY_AGE_ENV, SHARD_ENV,
-               SHARDS_ENV, INCARNATION_ENV, LANE_ENV)
+               SHARDS_ENV, INCARNATION_ENV, LANE_ENV, DATA_SLOT_ENV)
 
 DEFAULT_WAIT_S = 3600.0
 DEFAULT_POLL_S = 2.0
@@ -246,6 +246,9 @@ def renumber_group(samples: Sequence[dict[str, Any]], *, position: int,
 
 
 # ---------------------------------------------------------------------- sampler side
+DATA_ROW_KEY = "yeto_data_row"  # a sample's row index in the unsplit data (DataSlot)
+
+
 def apply_data_slot(data_source: Any, slot: DataSlot, *, shuffle: bool) -> int:
     """Keep only ``slot``'s rows in a Miles ``RolloutDataSource`` (S26 E9.3).
 
@@ -253,7 +256,10 @@ def apply_data_slot(data_source: Any, slot: DataSlot, *, shuffle: bool) -> int:
     original rows become the slot's rows, and the current epoch's order is made
     again from them (the same seeded shuffle, over the slot). The data cursor of
     a later round then counts in slot rows, so a replacement incarnation with
-    the same slot seeks to the same place. Returns the slot's row count."""
+    the same slot seeks to the same place. Each kept row records its index in
+    the unsplit data as ``metadata["yeto_data_row"]`` (it reaches the buffer with the
+    sample), so a run shows its samplers drew disjoint rows. Returns the slot's
+    row count."""
     source = getattr(data_source, "__self__", data_source)
     dataset = getattr(source, "dataset", None)
     if slot.whole or dataset is None:
@@ -265,6 +271,9 @@ def apply_data_slot(data_source: Any, slot: DataSlot, *, shuffle: bool) -> int:
             "(its dataset has no origin_samples)")
     if int(getattr(source, "sample_offset", 0) or 0) or int(getattr(source, "epoch_id", 0) or 0):
         raise SampleBufferRolloutError("the data slot is applied before the first draw")
+    for row, sample in enumerate(origin):
+        if isinstance(getattr(sample, "metadata", None), dict):
+            sample.metadata[DATA_ROW_KEY] = row
     dataset.origin_samples = slot.rows(origin)
     dataset.samples = list(dataset.origin_samples)
     if shuffle:

From 0b64895f5d57385575b5ebb3c4e8701d4d70ee43 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Wed, 21 Oct 2026 00:51:47 +0000
Subject: [PATCH 20/23] verl vLLM readback: one tmp file per replica process

On a 2-card verl sync island (e9b-g3-a) both vLLM replicas wrote
readback-v0.json through the same tmp name; the second os.replace raised
FileNotFoundError inside vLLM and the weight update failed. The tmp name now
carries the pid, and a write failure is printed instead of raised into vLLM.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_verl_multigpu.py     | 28 ++++++++++++++++++++++++++
 yeto/rl/adapters/verl/vllm_readback.py | 15 ++++++++++----
 2 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/tests/test_s26_e9_verl_multigpu.py b/tests/test_s26_e9_verl_multigpu.py
index b100341c..17d569c1 100644
--- a/tests/test_s26_e9_verl_multigpu.py
+++ b/tests/test_s26_e9_verl_multigpu.py
@@ -62,3 +62,31 @@ def test_modal_island_config_carries_the_default(monkeypatch, tmp_path, extra, w
     task = SimpleNamespace(envs={}, secrets={}, file_mounts={}, run="true", setup="")
     cfg = modal_islands.build_modal_island_config(args, spec, 0, task, "none")
     assert cfg.envs["NCCL_SHM_DISABLE"] == want
+
+
+def _write_readbacks(root: str, n: int) -> None:
+    import os
+
+    from yeto.rl.adapters.verl import vllm_readback as rb
+
+    os.environ[rb.READBACK_ENV] = root
+    for _ in range(n):
+        rb.after_add_lora(SimpleNamespace(), 1)  # a broken manager: the error record is written
+
+
+def test_readback_from_several_vllm_replicas_at_once(tmp_path):
+    """e9b-g3-a: two vLLM replicas (one per card) wrote readback-v0.json through one
+    shared tmp name; the second os.replace raised FileNotFoundError inside vLLM."""
+    import json
+    import multiprocessing
+
+    (tmp_path / "expected_version").write_text("0")
+    ctx = multiprocessing.get_context("fork")
+    procs = [ctx.Process(target=_write_readbacks, args=(str(tmp_path), 200)) for _ in range(2)]
+    for p in procs:
+        p.start()
+    for p in procs:
+        p.join(60)
+    assert [p.exitcode for p in procs] == [0, 0]
+    assert json.loads((tmp_path / "readback-v0.json").read_text())["version"] == "0"
+    assert not list(tmp_path.glob("*.tmp"))
diff --git a/yeto/rl/adapters/verl/vllm_readback.py b/yeto/rl/adapters/verl/vllm_readback.py
index e3c38688..8bd1d615 100644
--- a/yeto/rl/adapters/verl/vllm_readback.py
+++ b/yeto/rl/adapters/verl/vllm_readback.py
@@ -84,7 +84,14 @@ def after_add_lora(worker, lora_int_id: int, expected_shapes: dict | None = None
 
         result = {"error": f"{type(exc).__name__}: {exc}", "trace": traceback.format_exc()[-2000:]}
     result.update({"version": version, "pid": os.getpid(), "seconds": round(time.time() - t0, 3)})
-    tmp = path + ".tmp"
-    with open(tmp, "w") as handle:
-        json.dump(result, handle)
-    os.replace(tmp, path)
+    # One tmp file per process: an island with several vLLM replicas (one per card,
+    # S26 E9 e9b-g3-a) runs this in every replica at the same time, and a shared
+    # tmp name made the second os.replace fail inside vLLM (FileNotFoundError).
+    # The replicas hold the same adapter; the last complete record wins.
+    tmp = f"{path}.{os.getpid()}.tmp"
+    try:
+        with open(tmp, "w") as handle:
+            json.dump(result, handle)
+        os.replace(tmp, path)
+    except OSError as exc:  # never raised into vLLM; the trainer reports the missing readback
+        print(f"[yeto-verl] readback write failed: {exc}", flush=True)

From 0752eb4b5893fdb20264d15ede8e02fe0b0fff27 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Wed, 21 Oct 2026 01:33:57 +0000
Subject: [PATCH 21/23] Head syncer waits only for a synced group's trainers,
 not its sampler islands

cmd_head sized the head-local syncer with every --gpu island, so a synced group
(2 trainers + 1 sampler, e9b-sync-a) waited for 3 learners and the trainers
hung after connecting. It now uses sample_roles.syncer_learner_count, the same
count launcher.run uses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_head_mode.py | 20 ++++++++++++++++++++
 yeto/cli.py             |  8 ++++++--
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/tests/test_head_mode.py b/tests/test_head_mode.py
index 4cae7d12..4d1a2921 100644
--- a/tests/test_head_mode.py
+++ b/tests/test_head_mode.py
@@ -907,3 +907,23 @@ def test_head_public_image_sends_no_registry_login(fake_sky, monkeypatch, tmp_pa
     (_, job_task), = fake_sky["execs"]
     assert job_task.secrets == {"MODAL_TOKEN_ID": "ak-1", "MODAL_TOKEN_SECRET": "as-1"}
     assert not any(k.startswith("SKYPILOT_DOCKER") for k in (job_task.envs or {}))
+
+
+def test_head_syncer_skips_a_synced_groups_sampler_islands(monkeypatch):
+    """S26 e9b-sync-a: the head syncer waited for 3 learners (2 trainers + the
+    sampler island), so the two synced trainers never got their first round."""
+    seen = {}
+
+    class FakeSyncer:
+        def __init__(self, args, n):
+            seen["n"] = n
+            raise SystemExit(0)
+
+    monkeypatch.setattr(launcher, "LocalSyncer", FakeSyncer)
+    ns = cli.parse_args(["--training-mode", "rl", "--rl-backend", "verl", "--gpu",
+                         "modal:1xa10g,modal:1xa10g,modal:1xa10g", "--model", "Qwen/Qwen3-0.6B",
+                         "--data", "org/ds", "--rl-sample-role", "trainer", "--rl-island-sample-role",
+                         "2:sampler", "--rl-max-policy-age", "2", "--cluster-prefix", "hsg"])
+    with pytest.raises(SystemExit):
+        cli.cmd_head(json.dumps(cli._serializable_args(ns)))
+    assert seen["n"] == 2
diff --git a/yeto/cli.py b/yeto/cli.py
index 7c68497f..62f8c050 100644
--- a/yeto/cli.py
+++ b/yeto/cli.py
@@ -1538,9 +1538,13 @@ def cmd_head(payload: str) -> int:
         from .rl.sao_streaming_manifest import load_sao_streaming_manifest
 
         args.rl_sao_manifest = load_sao_streaming_manifest(args.rl_sao_contracts)
-    # Same count launcher.run uses: --gpu islands plus --external-learners
+    # Same count launcher.run uses: the synced islands (a synced group's sampler
+    # islands do not join the syncer, S26 e9b-sync-a) plus --external-learners
     # seats; without the seats the syncer rejects every manual joiner.
-    num_learners = len(parse_gpu_spec(args.gpu)) + (getattr(args, "external_learners", 0) or 0)
+    from .rl.engine import sample_roles
+
+    num_learners = (sample_roles.syncer_learner_count(args, len(parse_gpu_spec(args.gpu)))
+                    + (getattr(args, "external_learners", 0) or 0))
     syncer = launcher.LocalSyncer(args, num_learners)
     syncer.start()
     syncer.start_log_forwarder()

From c71130298ac2fb7c403176101c3cb764b41bd4b5 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Wed, 21 Oct 2026 01:53:56 +0000
Subject: [PATCH 22/23] Syncer quorum counts a synced group's trainers only

The strict and decoupled presets set --quorum to every --gpu island; in a
synced group (2 trainers + 1 sampler, e9b-sync-b) that is quorum 3 over
--learners 2, and the syncer exits at start. Both now use
sample_roles.syncer_learner_count.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_s26_e9_verl_pair_launch.py | 11 +++++++++--
 yeto/launch/rl_args.py                | 12 ++++++++++--
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/tests/test_s26_e9_verl_pair_launch.py b/tests/test_s26_e9_verl_pair_launch.py
index bac2b679..533ab9c8 100644
--- a/tests/test_s26_e9_verl_pair_launch.py
+++ b/tests/test_s26_e9_verl_pair_launch.py
@@ -173,7 +173,7 @@ def test_trainer_buffer_merges_named_shards(tmp_path):
     assert not plain._merge and plain._expected_shards is None
 
 
-def _group(monkeypatch, gpus, samplers, total_steps=4):
+def _group(monkeypatch, gpus, samplers, total_steps=4, scheduling="elastic"):
     """One launch of synced trainers plus sampler islands (S26 E9.4 synced group)."""
     from tests.test_rl_launcher import _Resources, _Storage, _StorageMode, _Task
     from yeto import launcher
@@ -186,7 +186,7 @@ def _group(monkeypatch, gpus, samplers, total_steps=4):
     extra = ["--rl-backend", "verl", "--rl-checkpoint-store", STORE, "--rl-max-policy-age", "2",
              "--reward-function", "gsm8k_reward:score", "--total-steps", str(total_steps),
              "--gpu", ",".join(["modal:1xa10g"] * gpus), "--rl-sample-role", "trainer",
-             "--rl-island-scheduling", "elastic"]
+             "--rl-island-scheduling", scheduling]
     for m in samplers:
         extra += ["--rl-island-sample-role", f"{m}:sampler"]
     args = _cli(tuple(extra))
@@ -225,6 +225,13 @@ def test_one_launch_starts_synced_trainers_and_their_sampler(monkeypatch):
     assert spec["num_rollouts"] == 8  # the rounds of both trainers (2 x 4)
 
 
+@pytest.mark.parametrize("scheduling", ["elastic", "legacy"])
+def test_synced_group_quorum_counts_trainers_only(monkeypatch, scheduling):
+    """e9b-sync-b: quorum 3 (every island) over --learners 2 made the syncer exit."""
+    args, learners, _ = _group(monkeypatch, 3, [2], scheduling=scheduling)
+    assert learners == 2 and args.quorum == 2
+
+
 def test_synced_group_with_two_samplers_shards_and_slots(monkeypatch):
     _args, learners, islands = _group(monkeypatch, 4, [0, 3])
     (s0, _, _), (t0, _, _), (t1, _, _), (s1, _, _) = islands
diff --git a/yeto/launch/rl_args.py b/yeto/launch/rl_args.py
index 0c21669b..0906c6d0 100644
--- a/yeto/launch/rl_args.py
+++ b/yeto/launch/rl_args.py
@@ -148,6 +148,14 @@ def sao_contract_mounts(args, learner_id: int) -> dict[str, str]:
             for shipped in (island.runtime, island.layout_attestation)}
 
 
+def _synced_learners(args, specs) -> int:
+    """Islands that join the syncer: a synced group's sampler islands do not
+    (S26 e9b-sync-b: quorum 3 over --learners 2 made the syncer exit)."""
+    from ..rl.engine.sample_roles import syncer_learner_count
+
+    return syncer_learner_count(args, len(specs))
+
+
 def _prepare_dense_full_sweep(args, *, num_islands: int) -> None:
     """full-parameter preset (P0-D8): one actor role swept as whole-model fragments.
 
@@ -732,7 +740,7 @@ def _prepare_rl_args(
             raise ValueError("decoupled RL pipeline must be between 1 and fragments")
         if args.fragment_pattern != "binpack":
             raise ValueError("decoupled RL requires --fragment-pattern binpack")
-        args.quorum = len(specs)
+        args.quorum = _synced_learners(args, specs)
         args.grace_ms = 0
         args.sync_interval_steps = float(args.local_rl_rounds_per_sync)
         args.delta_correction = "none"
@@ -747,7 +755,7 @@ def _prepare_rl_args(
         _prepare_sao_streaming(args, num_islands=len(specs))
     elif not args.experimental_rl_sync:
         args.fragments = 1
-        args.quorum = len(specs)
+        args.quorum = _synced_learners(args, specs)
         args.grace_ms = 0
         args.pipeline = 1
         args.sync_interval_steps = 0.0

From b1739c1d0ae176eaa2311acb927db34a12769ea2 Mon Sep 17 00:00:00 2001
From: michael <78113554+chowhsu@users.noreply.github.com>
Date: Wed, 21 Oct 2026 01:54:51 +0000
Subject: [PATCH 23/23] Dry-run plan sizes the role syncers like the real
 launch (synced group)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 yeto/launcher.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/yeto/launcher.py b/yeto/launcher.py
index 969a46d6..cb398506 100644
--- a/yeto/launcher.py
+++ b/yeto/launcher.py
@@ -1054,7 +1054,7 @@ def dry_run_plan(args) -> dict:
         "syncer": None if no_sync else ("head VM" if head else f"{args.cluster_prefix}-syncer"),
         # P0-D8: one syncer per trainable role (actor first); none without outer sync
         "role_syncers": [] if not rl or no_sync else _dry_run_role_syncers(
-            args, len(specs) + external),
+            args, sample_roles.syncer_learner_count(args, len(specs)) + external),
         "outer_sync": not no_sync,
         # rl-trainer-start-stop L5.3b/L5.4: the head's scheduler and the island it owns
         "trainer_scheduler": (None if not trainer_loop.enabled(args) else {