rosotacom-dev 2.5.dev17__tar.gz → 2.5.dev20__tar.gz

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/.github/workflows/nightly-e2e.yml

@@ -37,7 +37,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        slice: [core, transforms, remote-assist, runtime-tools, concurrency, media]
+        slice: [heartbeat, chatter, occupancy-grid, sized-payload, remote-assist, remote-assist-streams, runtime-tools, media, concurrency, benchmark-ab, benchmark-replay, benchmark-capacity, benchmark-capacity-cases]
 
     steps:
       - name: Check out repository

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/.github/workflows/pr-merge-gate.yml

@@ -27,7 +27,10 @@ jobs:
           ACTIONLINT_VERSION="1.7.12"
           CHECKSUM="8aca8db96f1b94770f1b0d72b6dddcb1ebb8123cb3712530b08cc387b349a3d8"
           URL="https://github.com/rhysd/actionlint/releases/download/v${ACTIONLINT_VERSION}/actionlint_${ACTIONLINT_VERSION}_linux_amd64.tar.gz"
-          curl -sSL -o actionlint.tar.gz "$URL"
+          # --fail, or a transient HTTP error body is saved as the tarball and
+          # reported as "computed checksum did NOT match" — which reads like a
+          # tampered release. That cost this PR a full gate run.
+          curl -sSLf --retry 3 --retry-all-errors -o actionlint.tar.gz "$URL"
           echo "${CHECKSUM}  actionlint.tar.gz" | sha256sum --check
           tar -xzf actionlint.tar.gz actionlint
           sudo mv actionlint /usr/local/bin/actionlint
@@ -197,6 +200,13 @@ jobs:
     # paragraph. The slice list is the same one release.yml expands, and
     # tests/contract/test_workflow_contracts.py keeps the three workflows and
     # the justfile agreeing.
+    #
+    # The slices are chosen by measured cost, not grouped by theme (#226):
+    # themed slices spanned 7m39s to 18m31s, and one test ran in two of them.
+    # Thirteen rather than six because the model that predicted the balanced
+    # six within 25s also says twelve reaches the floor and more buys nothing
+    # (#235). Which tests a slice owns and what each costs is E2E_SLICES in
+    # tests/e2e/conftest.py — change that, not this line, to move a test.
     name: e2e-${{ matrix.slice }}
     runs-on: ubuntu-latest
     timeout-minutes: 90
@@ -205,7 +215,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        slice: [core, transforms, remote-assist, runtime-tools, concurrency, media]
+        slice: [heartbeat, chatter, occupancy-grid, sized-payload, remote-assist, remote-assist-streams, runtime-tools, media, concurrency, benchmark-ab, benchmark-replay, benchmark-capacity, benchmark-capacity-cases]
 
     steps:
       - name: Check out repository

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/.github/workflows/release.yml

@@ -125,7 +125,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        slice: [core, transforms, remote-assist, runtime-tools, concurrency, media]
+        slice: [heartbeat, chatter, occupancy-grid, sized-payload, remote-assist, remote-assist-streams, runtime-tools, media, concurrency, benchmark-ab, benchmark-replay, benchmark-capacity, benchmark-capacity-cases]
 
     steps:
       - name: Check out repository

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev17
+Version: 2.5.dev20
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

rosotacom_dev-2.5.dev20/budgets.jsonl

@@ -0,0 +1,7 @@
+{"better": "lower", "hi": 0.5, "lo": -0.5, "metric": "loss_pct", "profile": "finding-3.2mbit", "provenance": {"fingerprint": "github-hosted-linux-x86_64", "floor": 0.5, "k": 3.0, "note": "boundary good-side seed from zero-loss-boundaries-18kb-20hz migrated evidence; ratchet after first nightly exercise", "ratcheted_at": "2026-07-09T00:00:00", "repeats": 9, "sigma": 0.0, "source_sha": "678be64", "window_s": 60.0}, "row": "boundary-loss-18kb20hz-bandwidth-cyclone", "schema": 2}
+{"better": "higher", "hi": 6238.32, "lo": 5993.68, "metric": "capacity_size", "profile": "gate-tight", "provenance": {"fingerprint": "github-hosted-linux-x86_64", "floor": 122.32000000000001, "k": 3.0, "note": "runner-class calibration, K=5 independent GitHub-hosted runs", "ratcheted_at": "2026-07-08T15:14:07", "repeats": 5, "sigma": 4.8166378315169185, "source_sha": "8e1b41f", "window_s": 10.0}, "row": "capacity-size-tight-cyclone", "schema": 2}
+{"better": "lower", "hi": 0.5, "lo": -0.5, "metric": "loss_pct", "profile": "gate-tight", "provenance": {"fingerprint": "github-hosted-linux-x86_64", "floor": 0.5, "k": 3.0, "note": "runner-class calibration, K=5 independent GitHub-hosted runs", "ratcheted_at": "2026-07-08T15:14:07", "repeats": 5, "sigma": 0.04528516758606621, "source_sha": "8e1b41f", "window_s": 60.0}, "row": "probe-loss-gop-tight-cyclone", "schema": 2}
+{"better": "lower", "hi": 0.5, "lo": -0.5, "metric": "loss_pct", "profile": "gate-nominal", "provenance": {"fingerprint": "github-hosted-linux-x86_64", "floor": 0.5, "k": 3.0, "note": "runner-class calibration, K=5 independent GitHub-hosted runs", "ratcheted_at": "2026-07-08T15:14:07", "repeats": 5, "sigma": 0.0, "source_sha": "8e1b41f", "window_s": 60.0}, "row": "probe-loss-nominal-cyclone", "schema": 2}
+{"better": "lower", "hi": 90.16056918160436, "lo": 53.625281678816286, "metric": "loss_pct", "profile": "gate-tight", "provenance": {"fingerprint": "github-hosted-linux-x86_64", "floor": 1.4378585086042066, "k": 3.0, "note": "runner-class calibration, K=5 independent GitHub-hosted runs", "ratcheted_at": "2026-07-08T15:14:06", "repeats": 5, "sigma": 6.089214583798013, "source_sha": "8e1b41f", "window_s": 60.0}, "row": "probe-loss-tight-cyclone", "schema": 2}
+{"better": "lower", "hi": 67.97722870550751, "lo": 48.049548219083945, "metric": "loss_pct", "profile": "gate-tight", "provenance": {"fingerprint": "github-hosted-linux-x86_64", "floor": 1.1602677692459147, "k": 3.0, "note": "runner-class calibration, K=5 independent GitHub-hosted runs", "ratcheted_at": "2026-07-08T15:14:08", "repeats": 5, "sigma": 3.3212800810705954, "source_sha": "8e1b41f", "window_s": 60.0}, "row": "probe-loss-tight-fastdds", "schema": 2}
+{"better": "lower", "hi": 0.5, "lo": -0.5, "metric": "loss_pct", "profile": "gate-tight", "provenance": {"fingerprint": "github-hosted-linux-x86_64", "floor": 0.5, "k": 3.0, "note": "runner-class calibration, K=5 independent GitHub-hosted runs", "ratcheted_at": "2026-07-08T15:14:08", "repeats": 5, "sigma": 0.0, "source_sha": "8e1b41f", "window_s": 60.0}, "row": "probe-loss-tight-zenoh", "schema": 2}

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/docs/ci.md

@@ -43,7 +43,7 @@ check is:
 ci-success
 ```
 
-The merge gate runs workflow lint, dependency/security review, runtime/build asset lint, Python 3.10 through 3.14 non-Docker checks, package validation, and the Docker single-machine smoke matrix (divided into 5 parallel lanes):
+The merge gate runs workflow lint, dependency/security review, runtime/build asset lint, Python 3.10 through 3.14 non-Docker checks, package validation, and the Docker single-machine smoke matrix (one matrix job per slice, thirteen in parallel):
 
 Python 3.10–3.14 are supported for the host CLI; Python 3.12 is the reference
 interpreter for packaging and Docker E2E jobs.
@@ -56,12 +56,20 @@ just typecheck
 just test-nondocker-cov
 just docs
 just package
-# Parallel E2E lanes:
-just test-e2e-core
-just test-e2e-transforms
-just test-e2e-remote-assist
-just test-e2e-runtime-tools
-just test-e2e-concurrency
+# Parallel E2E lanes, one per slice:
+just test-e2e-slice heartbeat
+just test-e2e-slice chatter
+just test-e2e-slice occupancy-grid
+just test-e2e-slice sized-payload
+just test-e2e-slice remote-assist
+just test-e2e-slice remote-assist-streams
+just test-e2e-slice runtime-tools
+just test-e2e-slice media
+just test-e2e-slice concurrency
+just test-e2e-slice benchmark-ab
+just test-e2e-slice benchmark-replay
+just test-e2e-slice benchmark-capacity
+just test-e2e-slice benchmark-capacity-cases
 ```
 
 The Python 3.12 leg uploads `coverage.xml` to Codecov with the `nondocker` flag.
@@ -69,18 +77,66 @@ Docker E2E is not collected for coverage.
 
 ## Docker E2E
 
-`just test-e2e-smoke` runs the entire local single-machine smoke matrix through Docker. In the CI merge gate, E2E testing is divided into parallel jobs (`e2e-core`, `e2e-transforms`, `e2e-remote-assist`, `e2e-runtime-tools`, `e2e-concurrency`) which run concurrently to minimize wall-clock time. Each smoke run writes generated
+`just test-e2e-smoke` runs the entire local single-machine smoke matrix through Docker. In the CI merge gate, the same collection runs as thirteen parallel
+jobs, one per slice, named `e2e-<slice>`. Each smoke run writes generated
 config, catmux pane logs, Docker logs when available, and the smoke verification
 log under `session-instances/`; collect that directory as the first debugging
 artifact when an E2E job fails.
 
+### Balancing the e2e slices
+
+A slice is not its own pytest invocation. `just test-e2e-slice <name>` runs the
+monolith's collection with `--e2e-slice=<name>`, and everything the named slice
+does not own is deselected. Which tests a slice owns, and what each one costs,
+is `E2E_SLICES` in `tests/e2e/conftest.py`; `just e2e-slice-costs` prints the
+resulting balance. Moving a test between slices is one line there — the
+workflow matrices only name slices.
+
+That shape exists because the previous one, per-slice file lists and `-k`
+filters, could not say what it ran. `-k "remote_assist"` silently missed the
+`[remote-assist-anonymized-*]` parameters, and `-k "remote_assist"` and
+`-k "anonymized"` silently *shared* one 262s test, which the gate therefore ran
+twice a run. A partition can do neither: an unowned test fails every slice job
+with a usage error, and a test owned twice fails
+`test_e2e_slices_partition_the_whole_suite`.
+
+The costs are warm pytest `call` durations — medians over seven merge-gate runs
+of 2026-08-11/12. On top of them each job pays a fixed
+`RUNNER_SETUP_SECONDS + IMAGE_BUILD_SECONDS` (3m29s: 55s of runner setup, then the
+project image built inside whichever test runs first). Because that constant is
+per job and not per test, balancing warm costs balances wall clock.
+
+### How many slices
+
+`floor_seconds()` is `fixed + slowest single test` — the fastest any partition
+of this suite could be, because one job has to run that test and pays the fixed
+cost like every other. It is currently **7m56s**, of which 2m34s is the image
+build (#236 is about removing it).
+
+Thirteen slices sit at 8m38s, 1.09x the floor. That is the point of choosing N
+from the numbers rather than from taste: six balanced slices were 13m37s,
+twelve reach the floor, and past twelve every extra job is pure cost. The
+contract test asserts distance to the floor rather than the spread between
+slices — spread is compressed toward 1.0 by the fixed cost as N grows, so it
+keeps reading fine while the gate stops improving.
+
+Runner minutes are not the constraint here (this repository is public, so
+standard GitHub-hosted runners are free); the concurrent-job cap is, and
+thirteen stays under it.
+
+To refresh the numbers, read a merge-gate run: every e2e invocation runs
+`--durations=0`, so each job prints the cost of every test it ran. A test that
+ran first in its job carries the image build and needs `IMAGE_BUILD_SECONDS`
+subtracted. `tests/contract/test_workflow_contracts.py::test_e2e_slices_stay_close_to_the_floor`
+fails when the slowest slice passes 1.25x the floor.
+
 ## Performance Regression Gate
 
 The deterministic benchmark rows gate against committed two-sided bands
 ([performance-bands.md](performance-bands.md), RFC 0007):
 
 - the `merge-gate` rows of the benched-set registry run inside the
-  `e2e-runtime-tools` lane (band-asserted benchmark-capacity E2E);
+  `e2e-benchmark-capacity` lane (band-asserted benchmark-capacity E2E);
 - `.github/workflows/benchmark-gate.yml` runs the `nightly` rows on schedule
   and on manual dispatch. Its matrix comes from
   `rosotacom benchmark rows --format ids`; each row uploads `result.json` plus

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/docs/performance-bands.md

@@ -74,6 +74,7 @@ rosotacom benchmark ratchet <run1> <run2> <run3> --budgets budgets.jsonl \
 
 Banded metrics today come from `probe` runs (`loss_pct`, plus
 `latency_p50_ms`/`latency_p95_ms` — monitor-only on shared runners),
+`replay` runs (the probe set plus `delivered_count` and `delivered_hz`),
 `capacity` runs (`capacity_<knob>`) and `recovery` runs (`t_recover_s`,
 `t_steady_s`, `recovery_burst`, `lost_during_outage_total`).
 
@@ -95,16 +96,35 @@ rosotacom benchmark row <id> \
 
 `benchmark row` runs the row's genre with its committed parameters, gates the
 result against `budgets.jsonl`, and writes a machine-readable
-`verdict.json` (`WITHIN` / `REGRESSED` / `IMPROVED` / `REFUSED`, metrics,
-bands, sha, runner fingerprint) for downstream tooling. `--monitor` reports
-without blocking; `--no-compare` is for calibration repeats.
+`verdict.json` (`WITHIN` / `REGRESSED` / `IMPROVED` / `EXPECT_FAILED` /
+`REFUSED`, metrics, bands, sha, runner fingerprint) for downstream tooling.
+`--monitor` reports without blocking; `--no-compare` is for calibration
+repeats.
+
+### Replay rows: gated by the bag, not only by a band
+
+A `genre: replay` row's load is not invented in the registry — every parameter
+(cadence, mean payload, interval jitter, window) is a measurement of the
+recording named in its `replay` block, and the loader refuses a row whose load
+has drifted away from it. The bags stay in the operator harness; what is public
+is their measured shape and the whole-bag `expect` fragment generated from them
+(`rosotacom expect from-bag`), which `benchmark row` asserts on every gating
+run: delivered count against `min_count`, delivered/expected against
+`completeness_min_ratio`, and delivered rate against `vs_bag_ratio × native_hz`.
+A run that misses any of them is `EXPECT_FAILED` and red, with the per-threshold
+reasons in `verdict.json` under `replay_expect`.
+
+That assertion is bag-derived rather than runner-derived, which is why replay is
+the one genre allowed to land a row with no banded metrics at all: it gates from
+the day it lands, and the bands follow from a calibration run on the runner
+class. Every other genre still needs at least one banded metric.
 
 Lanes (RFC 0007 §4):
 
 - **merge gate** — the `merge-gate` rows run inside the benchmark-capacity E2E
   (`tests/e2e/test_benchmark_capacity.py::test_merge_gate_row_is_band_asserted`,
-  lane `just test-e2e-runtime-tools`): minutes-scale, default RMW, one
-  rate-limited profile.
+  lane `just test-e2e-slice benchmark-capacity`): minutes-scale, default RMW,
+  one rate-limited profile.
 - **nightly** — `.github/workflows/benchmark-gate.yml` runs every `nightly`
   row on schedule (and on dispatch), uploads per-row verdicts plus the
   aggregated `benchmark-gate-summary` artifact (`benchmark gate-summary`), and

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/docs/rfcs/0007-regression-gate.md

@@ -123,7 +123,7 @@ links never gate; what changes is that deterministic rows now **block**:
 | Trigger | What runs | Verdict |
 |---|---|---|
 | per-PR (merge gate) | existing point-check suite **+ one minutes-scale regression row** (default RMW × one rate-limited profile, loss/capacity band) | **gate** |
-| nightly | the **regression matrix**: supported RMW variants × canonical profiles (nominal **and** tight) × loads (steady, GOP/a-b pattern, single-stream anonymized replay) + **boundary pairs** — all band-asserted | **gate** (red nightly = fix-first; promotion requires the candidate's nightly gate green) |
+| nightly | the **regression matrix**: supported RMW variants × canonical profiles (nominal **and** tight) × loads (steady, GOP/a-b pattern, single-stream anonymized replay) + **boundary pairs** — band-asserted, except replay rows awaiting calibration, which assert their bag's whole-bag expect fragment instead | **gate** (red nightly = fix-first; promotion requires the candidate's nightly gate green) |
 | nightly | long sweeps, ramps, frontier searches | monitor (unchanged) |
 | on-demand | real WLAN/cellular characterization | monitor; calibrates the emulation (unchanged) |
 
@@ -255,7 +255,30 @@ slices these into issues.
   `benchmark gate-summary`; setup failure, `REGRESSED`, and unbanked
   `IMPROVED` are all red. S2 anonymized costmap/camera replay rows now cover
   nominal and tight profiles, carrying whole-bag expect fragments and GOP-aware
-  metadata next to their committed bands.)*
+  metadata.)*
+- [x] **Replay genre**: `genre: replay` for rows whose load is a measurement of
+  a recording rather than a chosen number — the registry checks the load against
+  that recording's provenance (cadence, window, mean payload, interval jitter),
+  `benchmark row` asserts the whole-bag `expect` fragment on every gating run,
+  and `delivered_count` / `delivered_hz` join the genre's metric set.
+  *(`benched_set.GENRES`/`_validate_replay_load_matches_bag`/
+  `replay_expect_failures`, `cli_benchmark.drive_replay` and the `EXPECT_FAILED`
+  verdict, `benchmark._replay_metrics_from_result`. The four public S2 rows are
+  `genre: replay`.)*
+  **Why it is not `probe` with extra fields:** as probe rows the provenance was
+  decoration — nothing checked the load against the bag, and the `expect`
+  fragment was never read by anything that runs. The genre is what makes both
+  assertions exist.
+  **Public limit (honest):** the anonymized S2 bags are not public, so a public
+  row replays the bag's *measured shape*, not its bytes. Byte-faithful replay
+  stays in the operator harness (`_run_private_replay_rows`, harness #34).
+- [ ] **Replay row bands**: calibrate the four S2 rows on the runner class
+  (`.github/workflows/benchmark-calibrate.yml`, K repeats) and promote their
+  gated metrics out of `monitor` in the same change that commits the bands.
+  They land unbanded on purpose — a band is a measurement of the runner class
+  and must not be hand-written, while the bag-derived expect fragment gates from
+  day one. `tests/contract/test_benched_set_registry.py::test_public_s2_replay_rows_await_their_calibration`
+  fails the moment a band appears without the promotion.
 - [x] **Boundary must-fail rows**: oracle inversion (assert the failure
   signature) + happy-red messaging; seed with the documented 18 KB @ 20 Hz
   pairs. *(`GateRow.kind=boundary` + `benchmark row` now run good/bad sides,
@@ -303,7 +326,8 @@ slices these into issues.
 - [x] **Merge-gate row** — exercised by the merge gate itself (band-asserted
   benchmark-capacity E2E), runtime bounded by the workflow timeout.
   *(`test_benchmark_capacity.py::test_merge_gate_row_is_band_asserted` in the
-  `e2e-runtime-tools` lane of `pr-merge-gate.yml`; a 60 s probe window plus
+  `e2e-benchmark-capacity` lane of `pr-merge-gate.yml` — the `e2e-runtime-tools`
+  lane until #226 split the capacity probes out of it; a 60 s probe window plus
   session setup keeps it minutes-scale.)*
 - [x] **Nightly matrix** — one deliberately injected regression (canary
   branch) turns the lane red end-to-end; documented one-off exercise.
@@ -321,11 +345,36 @@ slices these into issues.
   which cannot run is red, not silently green.)*
 - [x] **S2 anonymized replay rows** — contract and unit tests pin the public
   costmap/camera rows in the nightly lane, their whole-bag expect fragments, GOP
-  metadata, calibrated bands, and the probe metrics that turn replay loss into a
-  canary failure.
+  metadata, and the delivery metrics that turn replay loss into a canary failure.
   *(`tests/contract/test_benched_set_registry.py::test_public_s2_replay_rows_carry_whole_bag_expect_metadata`,
-  `tests/contract/test_benched_set_registry.py::test_every_gated_metric_has_a_calibrated_band`,
   `tests/unit/test_benchmark.py::test_probe_metrics_include_completeness_and_payload_bandwidth`.)*
+- [x] **Replay load stays the bag's shape** — the registry refuses a replay row
+  whose cadence, window, mean payload or interval jitter has drifted from the
+  provenance it commits, and refuses an `expect.min_count` the bag's own message
+  count does not justify.
+  *(`tests/unit/test_benched_set.py::test_replay_load_must_stay_the_bag_shape`,
+  `::test_replay_expect_min_count_must_come_from_the_bag`,
+  `::test_replay_metadata_is_refused_on_a_synthetic_probe_row`.)*
+- [x] **Replay expect gates without a band** — an unbanded replay row runs
+  against an empty band store instead of refusing, reports `WITHIN` when the
+  whole bag arrived, and `EXPECT_FAILED` (exit 1, per-threshold reasons in the
+  verdict) when it did not; `--monitor` reports the same verdict without
+  blocking.
+  *(`tests/unit/test_cli_benchmark.py::test_replay_row_gates_on_the_whole_bag_expect_without_any_band`,
+  `tests/unit/test_benched_set.py::test_replay_expect_names_every_threshold_that_did_not_hold`.
+  Exercised for real once against Docker on a dev laptop:
+  `replay-costmap-nominal-cyclone` on `gate-nominal` delivered 1386 msgs at
+  9.9 Hz with 0 % loss and 674 kbit/s payload bandwidth → `WITHIN`, exit 0,
+  `bands: {}`; the same row pointed at a copy of the profile carrying netem
+  `loss 40%` delivered 28 msgs at 0.20 Hz → `EXPECT_FAILED`, exit 1, all three
+  thresholds named in the log and in `verdict.json`. That is the whole claim of
+  landing before calibration: the row is already a gate.)*
+- [ ] **Replay bands reviewed** — the calibration evidence for the four S2 rows
+  (K repeats on the runner class) is reviewed and committed together with the
+  promotion out of `monitor`. Pending: no calibration run has been made for
+  them; `::test_public_s2_replay_rows_await_their_calibration` holds the step
+  open. The `--no-compare` + `benchmark calibrate` path they need is exercised
+  by `tests/unit/test_cli_benchmark.py::test_replay_calibration_run_reports_spread_for_the_metrics_a_band_would_take`.
 - [x] **Findings checker** — contract test: a finding without `Verification:`
   fails the ledger check.
 - [x] **Manual (explicit):** the first calibration is reviewed — band widths

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/docs/testing.md

@@ -125,12 +125,26 @@ from one-host smoke.
 
 `just test-e2e-smoke` runs the entire set of local-checkable curated examples. In CI and for local convenience, you can run specific E2E test slices or nodes:
 
-- `just test-e2e-core`: Runs core communication smoke tests.
-- `just test-e2e-transforms`: Runs transport transforms (compression, payload sizes).
-- `just test-e2e-remote-assist`: Runs anonymized remote assist streams.
-- `just test-e2e-runtime-tools`: Runs runtime utility/metrics E2E checks.
-- `just test-e2e-concurrency`: Runs concurrency/isolation gate checks.
+- `just test-e2e-slice heartbeat`: the heartbeat matrix (and the opt-in RMW matrix).
+- `just test-e2e-slice chatter`: the native chatter scenario, smoke, and debug rig.
+- `just test-e2e-slice occupancy-grid`: compressed occupancy grid over both transports.
+- `just test-e2e-slice sized-payload`: sized payload over both transports.
+- `just test-e2e-slice remote-assist`: the full anonymized remote-assist rig.
+- `just test-e2e-slice remote-assist-streams`: its costmap and camera single-stream cuts.
+- `just test-e2e-slice runtime-tools`: link latency and live timeline stepping.
+- `just test-e2e-slice media`: anonymization and video quality.
+- `just test-e2e-slice concurrency`: the concurrency/isolation gate.
+- `just test-e2e-slice benchmark-ab`: the A/B reliability verdict.
+- `just test-e2e-slice benchmark-replay`: loss boundaries against costmap replay.
+- `just test-e2e-slice benchmark-capacity`: the band-asserted capacity rows.
+- `just test-e2e-slice benchmark-capacity-cases`: the capacity good/bad-case verdicts.
 - `just test-e2e-node <nodeid>`: Reruns a specific pytest node ID directly.
+- `just e2e-slice-costs`: prints what each slice costs and how balanced the six are.
+
+The slices are chosen by measured cost, and split where the tests already
+differ so a red job names an area. `E2E_SLICES` in `tests/e2e/conftest.py`
+decides which slice owns which test; see
+[ci.md](ci.md#balancing-the-e2e-slices) before moving one.
 
 The generated RMW matrix is available as an opt-in full local slice:
 

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/justfile

@@ -42,39 +42,16 @@ test-e2e-smoke:
 
 test-e2e-fast: test-e2e-smoke
 
-test-e2e-core:
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_smoke.py -k "heartbeat or chatter"
-
-test-e2e-transforms:
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_smoke.py -k "occupancy_grid or sized_payload"
-
-test-e2e-remote-assist:
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_smoke.py -k "remote_assist"
-
-# Two invocations on purpose: a shared `-k` filter would silently deselect
-# every test in the other files (contract-tested in test_benched_set_registry).
-test-e2e-runtime-tools:
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_smoke.py -k "link_latency"
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_timeline_stepping.py tests/e2e/test_benchmark_capacity.py tests/e2e/test_benchmark_ab.py tests/e2e/test_benchmark_replay.py
-
-# The remaining e2e files. Without this slice the partition is not one: the
-# monolithic `test-e2e-smoke` collects 28 tests, the other five collect 25, and
-# anonymization/video-quality/replay ran only in nightly and the release.
-test-e2e-media:
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_anonymize_e2e.py tests/e2e/test_video_quality_e2e.py
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_smoke.py -k "anonymized"
-
-test-e2e-concurrency:
-	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/test_parallel_smoke.py
-
-# The five slices partition `test-e2e-smoke`; the merge gate and the release
-# both run them in parallel. This wrapper exists so a workflow matrix can select
-# a slice while the recipe name in the `run:` line stays a literal — a name
-# assembled by matrix interpolation is invisible to
-# tests/contract/test_workflow_contracts.py::test_referenced_just_recipes_exist.
-# Run one named slice of the e2e suite.
+# Run one named slice of the e2e suite. Same collection as `test-e2e-smoke`,
+# with everything the slice does not own deselected — so a slice cannot miss a
+# test or run one twice, which per-slice file lists and `-k` filters both did.
+# Which tests a slice owns, and what each costs, is E2E_SLICES in
+# tests/e2e/conftest.py; `just e2e-slice-costs` prints the balance.
 test-e2e-slice slice:
-	just test-e2e-{{slice}}
+	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/ -m e2e --e2e-slice={{slice}}
+
+e2e-slice-costs:
+	{{python}} tests/e2e/conftest.py
 
 test-e2e-node nodeid:
 	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 "{{nodeid}}"

{rosotacom_dev-2.5.dev17 → rosotacom_dev-2.5.dev20}/pyproject.toml

@@ -103,6 +103,12 @@ select = ["B", "E", "F", "I", "UP"]
 [tool.ruff.lint.isort]
 known-first-party = ["rosotacom"]
 
+[tool.ruff.lint.per-file-ignores]
+# The e2e slice partition is a table of pytest node ids, which have to be
+# verbatim to select anything and run past 120 characters on their own. Folding
+# them would make the table neither readable nor greppable.
+"tests/e2e/conftest.py" = ["E501"]
+
 [tool.mypy]
 python_version = "3.12"
 mypy_path = "src"