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/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/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():
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_rl_verl_buffer_trainer.py b/tests/test_rl_verl_buffer_trainer.py
index 58dea824..b15ba1e5 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
@@ -234,8 +234,10 @@ def _trainer(tmp_path, store_dir, actor, *, rounds, required, base):
     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=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")
@@ -353,8 +355,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"))
 
@@ -469,3 +473,83 @@ 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))
+        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:
+            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]
+
+
+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/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_s25_g1c_sampler_resume.py b/tests/test_s25_g1c_sampler_resume.py
index 88ad0fa0..e29adaaa 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):
@@ -176,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_data_slots.py b/tests/test_s26_e9_data_slots.py
new file mode 100644
index 00000000..d9f09bc5
--- /dev/null
+++ b/tests/test_s26_e9_data_slots.py
@@ -0,0 +1,297 @@
+"""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)
+
+
+@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
+
+    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")
+
+
+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")
+    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/tests/test_s26_e9_preempt_marker.py b/tests/test_s26_e9_preempt_marker.py
new file mode 100644
index 00000000..c376afed
--- /dev/null
+++ b/tests/test_s26_e9_preempt_marker.py
@@ -0,0 +1,201 @@
+"""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_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_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():
+    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)"
+
+
+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_fully_async_cut.py b/tests/test_s26_e9_verl_fully_async_cut.py
new file mode 100644
index 00000000..288d88db
--- /dev/null
+++ b/tests/test_s26_e9_verl_fully_async_cut.py
@@ -0,0 +1,151 @@
+"""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()
+
+
+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/tests/test_s26_e9_verl_multigpu.py b/tests/test_s26_e9_verl_multigpu.py
new file mode 100644
index 00000000..17d569c1
--- /dev/null
+++ b/tests/test_s26_e9_verl_multigpu.py
@@ -0,0 +1,92 @@
+"""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
+
+
+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/tests/test_s26_e9_verl_pair_launch.py b/tests/test_s26_e9_verl_pair_launch.py
new file mode 100644
index 00000000..533ab9c8
--- /dev/null
+++ b/tests/test_s26_e9_verl_pair_launch.py
@@ -0,0 +1,287 @@
+"""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["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
+    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):
+    (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
+
+
+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
+    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", scheduling]
+    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)
+
+
+@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
+    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)
+
+
+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/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/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()
diff --git a/yeto/launch/modal_islands.py b/yeto/launch/modal_islands.py
index a7f12af6..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:
@@ -301,6 +316,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/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
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/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()}
 
 
 # ---------------------------------------------------------------------------
diff --git a/yeto/launcher.py b/yeto/launcher.py
index 0abd2f4b..cb398506 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 (
@@ -184,15 +184,29 @@ 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 {}),
                             **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-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_checkpoint_store", None) or getattr(iargs, "rl_elastic", False):
+        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)."""
@@ -304,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
@@ -618,6 +635,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
 
@@ -990,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):
@@ -1024,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 {
diff --git a/yeto/modal_runner.py b/yeto/modal_runner.py
index b25be3c4..870414d3 100644
--- a/yeto/modal_runner.py
+++ b/yeto/modal_runner.py
@@ -951,22 +951,124 @@ 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:
+            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)
+    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:
@@ -1194,6 +1296,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 +1406,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..4c701921 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,11 +84,12 @@
 # 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
 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
@@ -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,42 @@ 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).
+
+    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. 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:
+        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")
+    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:
+        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 +439,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/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/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/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..b401ef75 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:
@@ -212,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/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/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/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..c41fdeed 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
@@ -93,9 +100,34 @@ 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]:
+        """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)
+        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
@@ -114,8 +146,15 @@ 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)
             keep = collector.offer(SampleMeta(**meta))
             isl.call("yeto_keep_last" if keep else "yeto_drop_last")
         queue = isl.call("yeto_assemble")
@@ -154,12 +193,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 +246,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/island_entry.py b/yeto/rl/adapters/verl/island_entry.py
index ab6f640f..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
@@ -73,6 +75,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)
@@ -230,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.
 
@@ -289,6 +308,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))
@@ -320,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",
@@ -406,9 +434,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 +447,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/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 735b282e..77f27e2a 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
@@ -71,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),
@@ -130,7 +131,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 +147,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/adapters/verl/sampler_entry.py b/yeto/rl/adapters/verl/sampler_entry.py
new file mode 100644
index 00000000..4133d500
--- /dev/null
+++ b/yeto/rl/adapters/verl/sampler_entry.py
@@ -0,0 +1,155 @@
+"""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.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
+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),
+        # 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)
+    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/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(),
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)
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..736fb5e4 100644
--- a/yeto/rl/engine/engine_sampler_entry.py
+++ b/yeto/rl/engine/engine_sampler_entry.py
@@ -20,10 +20,15 @@
   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);
+  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 +67,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 +111,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 +140,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 +177,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
@@ -207,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)
 
 
@@ -217,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
 
@@ -274,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)
@@ -319,8 +341,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:
diff --git a/yeto/rl/engine/resume.py b/yeto/rl/engine/resume.py
index bfa3894e..954e8a83 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,58 @@ 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:
+        rank = 0
+        try:
+            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"
+        # 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,
+              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/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_buffer.py b/yeto/rl/engine/sample_buffer.py
index aa271588..538d63c3 100644
--- a/yeto/rl/engine/sample_buffer.py
+++ b/yeto/rl/engine/sample_buffer.py
@@ -356,12 +356,18 @@ 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."""
-    return FileSampleBuffer(store, batch_size=batch_size, create_index=create_index, lane=lane,
-                            merge_shards=needs_shards(store) and merges_shards(lane), **kwargs)
+    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. 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 or merge, lane=lane,
+                            merge_shards=merge, expected_shards=named if merge and named else None, **kwargs)
 
 
 class FileSampleBuffer:
diff --git a/yeto/rl/engine/sample_roles.py b/yeto/rl/engine/sample_roles.py
index de65b83f..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,12 +266,17 @@ 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):
         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)
@@ -232,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:
@@ -424,4 +532,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/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()
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