diff --git a/lib/python/examples/_metadata/baselines.yaml b/lib/python/examples/_metadata/baselines.yaml
index 6de499971..8ee6e05df 100644
--- a/lib/python/examples/_metadata/baselines.yaml
+++ b/lib/python/examples/_metadata/baselines.yaml
@@ -212,6 +212,29 @@ baselines:
       hyperparameters:
         use_oort_loss_fn: "True"
 
+  oort_star:
+    description: >-
+      oort_star = oort sync + FedAvg + aware-at-selection (avail_select_filter=True),
+      no proactive in-flight eviction (reactive-90s). Differs from oort only in
+      avail_select_filter; the experiment config_overrides set avail_select_filter=True
+      (oort sets it False there). Uses same oracular tracking path.
+    example:
+      aggregator_main: aggregator/pytorch/main_oort_sync_agg.py
+    aggregator:
+      selector:
+        sort: oort
+        kwargs: {}
+      optimizer:
+        sort: fedavg
+        kwargs: {}
+      hyperparameters:
+        trackTrainerAvail:
+          enabled: "True"
+          type: ORACULAR
+    trainer:
+      hyperparameters:
+        use_oort_loss_fn: "True"
+
   fedbuff:
     description: FedBuff = fedbuff selector (uniform async) + fedbuff optimizer. Async stack.
     example:
diff --git a/lib/python/examples/async_cifar10/PARITY.md b/lib/python/examples/async_cifar10/PARITY.md
index 2cf0c8f60..bb07ce2a7 100644
--- a/lib/python/examples/async_cifar10/PARITY.md
+++ b/lib/python/examples/async_cifar10/PARITY.md
@@ -1,9 +1,16 @@
 # Real / Sim Parity — Methodical Causal Ladder
 
-Living doc for the async_cifar10 parity checker. Kept in sync with
+Living doc for the parity checker. Kept in sync with
 `scripts/parity/checks.py` (checks), `scripts/parity/report.py` (stage grouping +
 verdict), and the pytest suite. **ONE `## Status` section, updated in place.**
 
+**Scope: this is the shared parity methodology, not one example's.** The ladder (§1), roles/
+tiers/dependency-gating, workflow policy, run-length budget, and mechanism reference (§3) are
+**example-agnostic**. The async_cifar10 rung catalog (§2) is the reference instance; a second
+example appends its own rung catalog rather than forking the method. **fwdllm** (forward-gradient,
+variance-gated dynamic-K FL) is catalogued in **§F** — its build plan lives in
+`examples/fwdllm/simulate_fwdllm.md`, which references §F for rung definitions.
+
 **Comparator — give two run dirs, get a report JSON:**
 ```bash
 cd lib/python/examples/async_cifar10
@@ -702,3 +709,103 @@ refl overriding.
 | S | refl exploitation | FIXED: was deterministic top-k; now fork's cut_off_util-weighted `np.random.choice` |
 | D7 | UCB temporal-uncertainty `time_stamp` | **FIXED (Jun 23, §S.temporal).** Reference Oort+REFL: `sc += sqrt(0.1·log(round)/time_stamp)`, `time_stamp=self.epoch` (agg round of last RECEIPT), init at registration → never None, always contributes, up-weights under-selected/slower-returning clients. flame bug: refl's term was DEAD (0/7513) — `refl_oort.select()` let it divide by a None `time_stamp`; oort used last-SELECTED (dispatch round) with a None→0 guard. **Fix:** `PROP_LAST_RETURNED_ROUND` stamped at every receipt (fresh+stale) in oort/top_aggregator = agg round; selector reads it, registration-init lazy to current round; both oort+refl. `enable_temporal` kwarg (default True; False = ablation only). The legacy last-SELECTED machinery (`_record_last_selected_round`, D5) is REMOVED from OortSelector (no baseline used it); D5's MODEL_VERSION value was for staleness, not this UCB term. felix AsyncOortSelector is a separate class — untouched. |
 | D8 | `pacer()` round_threshold adaptation | **FIXED (Jun 24, §S.pacer).** Reference (`oort.py:184-199`) makes TWO symmetric moves on the exploited-utility trend: FLAT `|Δ|≤0.1·last` → `round_threshold += pacer_delta`, SHARP `|Δ|≥5·last` → `round_threshold = max(pacer_delta, −pacer_delta)`, keyed on `training_round`. flame's base `OortSelector.pacer()` raised on ANY dip (`last > curr`) with NO decrease branch → monotonic ratchet to 100, noise-sensitive → sim/real `round_threshold` diverged & back-half-compounded (the oort §S.pacer root). **Fix:** faithful both-branch port keyed on the current round, `pacer_step>0` guard; `REFLOortSelector.pacer` override (already faithful) REMOVED so oort+refl share the base; `round_threshold` added to selection telemetry. Guard `TestPacerFidelity`. **Cross-checked vs the REFL fork too** (`third_party/REFL/thirdparty/oort/oort.py`:176-201, byte-identical pacer, only round_threshold=30 default differs). **felix `AsyncOortSelector` (separate class) had the SAME bug + fired the pacer on its eval hand off a stale round → ALSO fixed** (faithful two-branch, train-gated; `test_async_oort_pacer_faithful`); changes felix dynamics → re-validate its 46/46 next run. |
+
+---
+
+## §F  FwdLLM extension -- variance-gated dynamic-K (forward-gradient FL)
+
+The method above (§1-§5) is example-agnostic; this is fwdllm's rung catalog. Rungs not
+redefined here are inherited from §2 unchanged. `[NEW]` = to implement. The fwdllm build plan
+(staged implementation, files, exit criteria, design decisions) is
+`examples/fwdllm/simulate_fwdllm.md`; this section is the rung reference it points at.
+
+### §F.1  How FwdLLM differs (drives every new rung)
+- **Aggregates GRADIENTS (JVPs), not weights.** Trainers send forward-gradient estimates; the
+  aggregator accumulates them into `grad_pool` and applies a server-LR SGD step at commit.
+  Gradient **values** depend on real GPU compute (run for real in sim) -> mode-invariant given
+  identical input + perturbation seed. What differs across modes is **which** gradients arrive,
+  **in what order**, against **which model version** = clock + selection + ordering fidelity.
+  This is what makes the §2 ladder applicable to fwdllm at all.
+- **Commit cadence is ENDOGENOUS (variance-gated dynamic-K).** At each `_agg_goal` (=K) boundary,
+  `aggregate()` computes `var`; `var <= var_threshold` -> **commit** (server step, eval,
+  `data_id += 1`, `model_version += 1`, clear `cached_v`); else **roll back**, push grads to
+  `cached_v`, `iteration_per_data_id += 1`, **retry the same data_id**;
+  `max_iterations_per_data_id` force-commits despite a failed variance gate. So
+  updates-per-`model_version` is a **random variable** of the gradient-variance trajectory -- the
+  `model_version` clock is not a fixed function of update count. A round is the outer loop over
+  data bins; `_round += 1` only when `data_id == total_data_bins` (=150).
+- **Dynamic K and C.** `DynamicKCController.step(metrics)` may change K (`_agg_goal`) and C
+  (concurrency) from observed metrics (var-pass ratio, eligible-ends) after each agg-goal cycle.
+- **Eval per variance-pass.** `eval_model()` runs on **every** committed data_id, not a fixed
+  schedule; its modeled delay must be stamped separately (a stale-eval `sct` past-dates the clock).
+- **Progress axis is `data_id`** (committed variance passes), not raw update count -- all
+  throughput/terminal rungs re-key to `data_id`.
+
+> **Crux:** in async_cifar10 clock and commit-count are loosely coupled; in fwdllm the commit
+> (model-version) cadence is a *feedback function of gradient variance over the accumulated pool*.
+> The sim must reproduce not just **when** updates arrive (clock) but the **variance trajectory**
+> gating each commit. Variance is mode-invariant **iff** the contributing set + order +
+> model-version of gradients matches -- reducing fwdllm parity back to clock + selection + ordering
+> parity, **plus** a new variance-cadence verification layer (§F.4).
+
+### §F.2  Baseline matrix (fwdllm)
+Filled from the landed `examples/fwdllm/expt_scripts/*_n10_smoke.yaml`. Maps onto the
+async_cifar10 availability taxonomy (`avail_select_filter` / `proactive_inflight_evict`,
+Unavailability §Baseline matrix).
+
+| baseline | sync/async | selector | agg | tracking_mode / avail | reselection | K (agg_goal) | dynamic_kc |
+|---|---|---|---|---|---|---|---|
+| **fluxtune** | async | `async_oort` | fedbuff (+server LR, JVP) | `client_notify` (3-tier, mobiperf_3st_50) | -- | 3 | disabled (fixed K/C) |
+| **fwdllm** | sync | `random` | fedavg | `default` (unaware) | per-round | 10 (=c; all selected required) | -- |
+| **fwdllm_plus** | sync | `random` | fedavg | `oracular` (`_metadata`, mobiperf_2st) | per-iteration (`reselect_each_iteration=True`) | 2 | -- |
+
+Decides scope: Stage 3 oort rungs (Sx/Sd/S2) run only for **fluxtune** (`async_oort`); the two
+`random`-selector baselines skip them. Stage 5 sync-barrier rungs run for **fwdllm**/**fwdllm_plus**
+(sync); fluxtune streams per-message. `client_notify` (fluxtune) is async_cifar10's deferred Stage-H
+tracking model -- see simulate_fwdllm.md decision D1.
+
+### §F.3  Modified rungs (async_cifar10 meaning -> fwdllm redefinition)
+| ID | async_cifar10 | FwdLLM redefinition |
+|---|---|---|
+| **K3a** | K-th fastest async commit advance | advance of `model_version` **per committed data_id** (clock delta between successive **variance passes**) |
+| **K3b** | overhead residual ~= 0 | same, measured on the **variance-pass** boundary |
+| **K2** | model versions / vsec | **committed data_ids / vsec** (throughput of *successful* variance passes) |
+| **U3** | version gap at commit | gap of each contributing gradient vs `model_version` at the cycle it lands -- spread across **multiple iterations per data_id** |
+| **K8 / U2** | @ matched model_version | @ matched **data_id** (the meaningful progress axis) |
+
+### §F.4  New rungs -- the variance-cadence layer (the fwdllm prize)
+Append-only, deps let the engine localize. Never fix an EMERGENT rung directly (§1): walk down to
+the lowest variance-cadence rung whose inputs are matched.
+
+**Stage 6' -- Variance-gated aggregation cadence** (dep Stage 5 ordering + Stage 1 clock)
+
+| ID | Check | Role/Tier | Isolates | Dep |
+|---|---|---|---|---|
+| **V1** `[NEW]` | iterations-per-data_id dist (realized dynamic K) | MECHANISM/DIST | # accumulation cycles to pass variance => contributing set/order diverged | U5,U4 |
+| **V2** `[NEW]` | per-cycle `var` trajectory (at each agg-goal) | MECHANISM/DIST | variance *signal* diverges with matched inputs => grad-pool composition/order differs | V1 |
+| **V3** `[NEW]` | `cached_v` pool size over time | MECHANISM/DIAG | rollback/cache bookkeeping diverges | V1 |
+| **V4** `[NEW]` | force-commit freq (`max_iterations_per_data_id` bypass rate) | MECHANISM/DIST | cap hit at a different rate => chronic variance divergence | V1 |
+| **V5** `[NEW]` | variance-pass ratio per window | EMERGENT/DIST | rollup feeding DynamicKC | V1,V2 |
+
+**Stage 3' -- Dynamic K/C trajectory** (dep Stage 3 selection + V5)
+
+| ID | Check | Role/Tier | Isolates | Dep |
+|---|---|---|---|---|
+| **DK1** `[NEW]` | K (`_agg_goal`) trajectory | MECHANISM/DIST | DynamicKC sees different metrics => K diverges (feeds back into cadence) | V5 |
+| **DK2** `[NEW]` | C (`dynamic_c`) trajectory | MECHANISM/DIST | concurrency target diverges | V5,S3/4 |
+| **DK3** `[NEW]` | eligible-ends-count metric fed to policy | CONTROL/DIST | the policy *input* differs (fix input, not policy) | A2 |
+
+**Stage 7' -- Forward-gradient quality**
+
+| ID | Check | Role/Tier | Isolates | Dep |
+|---|---|---|---|---|
+| **G1** `[NEW]` | per-update grad/JVP norm or SNR dist | EMERGENT/DIST | grad *quality* diverges (should be ~mode-invariant; FAIL = perturbation seed/order leaked) | S2,T_gpu |
+| **G2** `[NEW]` | grad_pool size at commit (realized contributions) | EMERGENT/DIST | rollup of V1 x K | V1,DK1 |
+
+> **Decomposition:** `K2`(throughput)x but `K3a`(per-pass advance)ok -> clock fine, commit count
+> diverged -> walk to V1/V5. `V1`x + `V2`ok-given-matched-input -> the *inputs* to variance differ
+> -> walk to U5/S2. `V2`x with V1 inputs matched -> a true grad-pool accumulation-order bug.
+> **DynamicKC coupling:** validate DK3 (policy *input*) before DK1/DK2 -- a diverging input means
+> fix the metric, not the policy (CONTROL before MECHANISM). `var_threshold` /
+> `max_iterations_per_data_id` are **baseline-defining config knobs, not parity levers** -- a
+> cadence gap is always an upstream set/order/clock divergence.
diff --git a/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md b/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md
index c89361578..10177ea23 100644
--- a/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md
+++ b/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md
@@ -1,318 +1,283 @@
-# Sim Unavailability — Design & Staged Plan
+# Sim Unavailability -- Design & Remaining Work
 
-**Status:** design settled (all open questions resolved Jun 25); implementation NOT started.
-Pickup-ready reference for adding trainer **unavailability** to the high-fidelity async_cifar10
-sim — and the template for the same feature in fwdllm ([simulate_fwdllm.md](../fwdllm/simulate_fwdllm.md) §7).
+Design + status for modeling client **unavailability** in the FLAME FL simulator. The mechanism is
+built and landed across all six async_cifar10 baselines; **felix is confirmed at full parity**. This
+doc now carries mostly **open items + next-steps**; landed history is collapsed to pointers (full detail
+in git). The fwdllm port has its own plan in
+[../fwdllm/simulate_fwdllm.md](../fwdllm/simulate_fwdllm.md) (parity rungs in
+[PARITY.md §F](PARITY.md)).
 
-**Prerequisites (read first):** [PARITY.md](PARITY.md) §1–§2 (the causal ladder, role/tier tags,
-dependency gating) and its §3 mechanism reference (`_vclock`, §3.drain, §3.resid, §4.5/§4.9, §S.dur).
-This feature extends that ladder; every new rung and mechanism below assumes that vocabulary.
+---
 
-**Goal:** let trainers drop in/out of `AVL_TRAIN` / `AVL_EVAL` / `UN_AVL` per their traces inside
-the sim, emitting correct client-side notifications on the **virtual clock**, without (a) breaking
-the parity already won at 100% availability, (b) a per-tick MQTT broadcast storm, or (c)
-frozen-clock deadlocks.
+## Status (Jul 2) -- felix CONFIRMED, fedbuff blocked, cross-baseline validation pending
+
+- **felix: FULL PARITY, 62/62 enforced checks** (live n=300 syn_50, `--runtime-s 3150`). Clock/timebase,
+  availability composition, selection, dispatch/training phases, staleness, and outcomes all PASS; real
+  self-stops cleanly (`"stopping run"`, no external kill, no `SIM_WALL_CEILING`). This is the reference
+  baseline the project set out to validate -- essentially PR-ready on its own.
+- **fedbuff: NOT yet trustworthy.** Its run from the same campaign was **confounded** by a concurrent
+  felix-real run: fedbuff-real's per-round pacing collapsed ~3 min after felix-real launched (5-10s/round
+  -> 40-80s+/round) while felix-real stayed steady. The two ran on **separate nodes** with flat RAM / 0%
+  GPU on fedbuff's node, so it is **not** local CPU/GPU/RAM contention -- leading suspects are a shared
+  MQTT broker under ~600 concurrent real trainer connections, a shared network path, or shared
+  storage/telemetry-write contention. Not yet root-caused.
+
+### Next steps (this workstream)
+1. **fedbuff shared-resource investigation** -- root-cause what collapsed fedbuff-real's pacing when
+   felix-real started despite separate nodes (broker / network / storage). Do this before a blind re-run.
+2. **fedbuff isolated re-run** (+ sim) once understood, or at minimum confirmed no other n=300 real run is
+   active anywhere in the shared environment during its window; re-check parity.
+3. **PR scoping** -- felix is PR-ready (62/62, clean self-stop). Decide whether to scope the PR to felix
+   now and follow up on fedbuff, or hold for both per the standing "land baselines together" agreement.
+
+### Next steps (parallel branch -- can proceed independently, merge fixes back as they land)
+Exhaustive cross-baseline validation is **not** a blocker for landing the substrate. On a parallel branch,
+run the full parity campaign for **oort / oort_star / refl / feddance** across **syn_0 / syn_20 / syn_50 /
+mobiperf**, sim+real, at n=300; resolve the still-open §7 rows; fixes merge back into `dg-fork-main` as
+they come. See "Open items" for the ordered gates (legacy `trackTrainerAvail` cleanup, mobiperf live
+exercise) and PARITY.md's run-length budget.
 
 ---
 
-## 0. What already exists (design *with* the grain)
+## Preamble -- what this is
+
+**Goal.** Model client *unavailability* (devices dropping offline mid-training) so a fast **simulated**
+run (virtual clock, no real sleeps) reproduces what a **real** run (wall-clock, MQTT, true delays) does --
+**sim/real parity** -- for every baseline, **config-gated and default-OFF** (byte-identical to today when off).
+
+**What was built (v1).** A shared availability substrate (`flame/availability/trace.py` +
+`ClientAvailability`) mixed into the syncfl base and inherited by asyncfl/oort, so all baselines share one
+trace-read effect path:
+- **Send-time gate, deliver-late-stale.** A trainer that goes UN_AVL mid-flight *keeps computing*; its
+  upload is gated at send-time (real) / buffered to `delivery_ts = max(sct, next_avail)` (sim) and
+  committed later as a stale update. Nothing is cancelled or dropped.
+- **Two ledgers, never conflated.** Slot ledger (90s vclock *abandon* frees the in-flight slot) + delivery
+  ledger (`pending_withheld[end]=delivery_ts`, commits through the existing staleness gate).
+- **Proactive in-flight eviction** -- **felix only** (the one fully-aware baseline): frees a slot the trace
+  shows UN_AVL at the next selection boundary, no 90s wait.
+- **Starvation / vclock-advance under scarcity.** When the eligible pool is too small to start a round, sim
+  advances the vclock to the next availability transition instead of spinning (self-terminating, B2.0.2).
+- **Absolute (vs. ground-truth-trace) fidelity checks** on top of the relative (real-vs-sim) ones: A6
+  (trainer state), A7 (aggregator belief, per selection/commit checkpoint), A8 (send-gate wait), K11
+  (commit promptness). Relative checks answer "do the two modes agree?"; these answer "is either one
+  *correct*?" -- shared `scripts/parity/ground_truth.py`, one canonical trainer<->aggregator time origin.
+- **Parity ladder** (`scripts/parity/`) -- availability rungs A1/A3/A4/A4dur/A5/A6/A7/A8/K11,
+  withheld_delivery, abandon_timeout, starvation_advance, eligible_pool_reduction.
+
+**Two orthogonal axes per baseline (keep separate).**
+1. **Knowledge at selection** (`avail_select_filter`): does the selector read the trace to avoid
+   *selecting* currently-UN_AVL trainers? aware = yes, unaware = select blind.
+2. **In-flight slot-free timing** (`proactive_inflight_evict`): when a *dispatched* trainer goes UN_AVL
+   mid-round, free its slot at the next boundary (proactive, felix only) or wait the 90s vclock abandon
+   (reactive-90s, everyone else). Aware-at-selection != in-flight eviction.
+
+The knowledge *model* is **trace-read** for all v1 baselines; message-transport (`client_notify`) and
+predictive models are **Stage H** (future).
+
+---
+
+## Working agreement (standing -- read every session)
+
+1. **Common first, one baseline first.** Land shared/library changes once, drive a single reference
+   baseline; don't fan out until it behaves.
+2. **Short runs to debug, long runs to confirm.** Gate on unit tests + syn_0 byte-identity + shortest
+   syn_20 smoke. Long runs confirm; never find first bugs.
+3. **Local deterministic tests before runs.** Prefer a synthetic-trace pytest that exhibits the bug over a
+   long run that hunts for it.
+4. **Keep this doc crisp.** Completed stages: mechanism + where it lives + exit (2-3 lines). Full detail
+   only for active/next; dead-ends in §6.
+5. **No stale content.** The moment a section is superseded -- a bug fixed, a task landed, a prediction
+   resolved, a next-step taken -- collapse it to a 2-3 line note (or delete) **in the same edit**.
+6. **Whole-doc crisp pass on every edit.** Re-read top to bottom and push down anything the new result also
+   supersedes. The top of the doc carries only **open issues** + **next steps**; run commands, wall-time
+   estimates, and per-run hypothesis tables for finished work belong in raw logs.
+
+---
 
-The tree already has **three** availability paths; the 100%-avail runs left them dormant
-(`trainer_event_dict`/`trainer_unavail_durations` default `None`). Reconcile these, don't add a fourth.
+## Baseline matrix (CANONICAL)
+
+| baseline | sync/async | agg base / entry | knowledge @ selection (`avail_select_filter`) | in-flight slot-free (`proactive_inflight_evict`) | config-gate (as run) |
+|---|---|---|---|---|---|
+| **felix** | **async** | `asyncfl` (<- syncfl) / `main_asyncfl_agg.py` | aware | **proactive** (felix only) | `simUnavailability` |
+| **fedbuff** | **async** | `asyncfl` / `main_asyncfl_agg.py` | unaware | reactive-90s | `simUnavailability` |
+| **oort** | **sync** | `oort/top_aggregator` / `main_oort_sync_agg.py` | unaware | reactive-90s | `simUnavailability`+ |
+| **oort_star** | **sync** | `oort/top_aggregator` / `main_oort_sync_agg.py` | aware | reactive-90s | `simUnavailability`+ |
+| **refl** | **sync** | `syncfl` FedAvg / `main_fedavg_agg.py` | aware | reactive-90s | `simUnavailability`+ |
+| **feddance** | **sync** | `syncfl` FedAvg / `main_fedavg_agg.py` | aware | reactive-90s | `simUnavailability` |
+
++ oort/oort_star/refl's `baselines.yaml` catalog entry still carries the legacy `trackTrainerAvail:
+{enabled: True, type: ORACULAR}` block (pre-dates this project). In every `debug_run.sh --trace`-launched
+run the substitution sets `simUnavailability=True` for them too, so they run the same modern path. The
+legacy block only matters if the parity YAML is loaded *without* that substitution -- untested territory,
+and the reason it isn't cleaned up yet (removing it risks silently disabling availability in that path).
+See Open item 1.
+
+**Notes.** (1) `ClientAvailability` lives in `flame/availability/client_availability.py`, mixed into
+`syncfl/top_aggregator.py` (`class TopAggregator(ClientAvailability, Role)`); asyncfl/oort extend it -- all
+six share the substrate. (2) trace-read is v1; the knowledge model becomes message-transport / predictive
+in Stage H, but the select-filter / in-flight-evict *behavior* is unchanged. (3) **felix is the only
+baseline that de-selects an in-flight trainer** when it goes UN_AVL; the aware-at-selection-only baselines
+still hit the 90s abandon for mid-round drop-offs.
+
+### Flag reference
+- `avail_select_filter: bool` -- selector excludes currently-UN_AVL trainers from the **selection** pool
+  (`get_curr_task_ineligible_trainers`). ON: felix/oort_star/refl/feddance. OFF: oort/fedbuff.
+- `proactive_inflight_evict: bool` -- gates `_sim_evict_unavail_inflight` (in-flight boundary eviction).
+  ON: **felix only**. OFF: everyone else (reactive-90s).
+- `tracking_mode` -- knowledge-model axis: `trace_read` (v1, live) | `client_notify` (Stage H) |
+  `predictive` (future). Replaces the `oracular` value at concept/log level (YAML field *value* compat kept).
 
-| # | Path | Where | Time-base | Drives |
-|---|---|---|---|---|
-| **A. Agg pull (event trace)** | `get_curr_unavail_trainers()` binary-searches each trainer's `trainer_event_dict` (SortedDict `ts→state`) | syncfl/oort/asyncfl top_agg | `_vclock.now` (sim) / `time.time()−agg_start` (real) | `channel.set_curr_unavailable_trainers` at selection |
-| **B. Agg pull (duration windows)** | `oracular_trainer_avail_check(end)` tests `trainer_unavail_durations[end]` `(start,dur)` | `asyncfl/top_aggregator.py:1264` | same | per-pick veto |
-| **C. Trainer push (notifications)** | `check_and_update_state_avl` pops trace events → `channel.update_trainer_state` → backend → `Channel.update_state` (evicts `UN_AVL` / `AVL_TRAIN→AVL_EVAL` from `selected_ends`) | `trainer/pytorch/main.py` + `channel.py:1056` | `_sim_now()` = last dispatch `_sim_send_ts` (sim) / wall (real) | MQTT message |
+---
 
-**Two anchoring facts:**
-1. **A/B already key on `_vclock.now` in sim** (comment at `asyncfl/top_aggregator.py:1264`:
-   *"wall-clock would barely advance vs the sim timeline, so every unavailability window would be
-   missed"*). Aggregator-pull on the virtual clock = the no-comms, deterministic, never-freezes path.
-2. **C has a frozen-clock defect in sim:** `_sim_now()` returns `_sim_send_ts`, which only updates
-   when the trainer is *dispatched*. An unselected trainer never advances → never pops events → never
-   notifies; a trainer that goes `UN_AVL` can't be selected → can't advance → **stuck `UN_AVL`
-   forever**. So C cannot be the source of truth for *selection* in sim until this is fixed.
+## v1 core decisions (resolved -- durable reference)
+
+- **Knowledge model:** trace-read for all; one shared trace + `state_at(trainer, vclock)` + one effect path.
+- **Mid-flight UN_AVL = compute-completes, gate the send, deliver-late (stale).** Real: gate at send-time.
+  Sim: buffer at `delivery_ts = max(sct, next_avail_ts)`.
+- **Two ledgers, never conflated:** slot ledger (frees `selected_ends`) + delivery ledger
+  (`pending_withheld`, commits stale through the staleness gate). Order commits by `(delivery_ts, end_id)`,
+  never `sct`.
+- **Busy != unavailable != withheld** -- three distinct non-pool states. Never route busy->UN_AVL.
+- **All availability time on the vclock in sim.** Never wall, never a frozen per-trainer clock.
+- **Config-gated, default OFF** => byte-identical. `simUnavailability` is the gate for all 6 baselines as
+  run (see Baseline matrix + note).
+- **availability state** (`AVL_TRAIN/AVL_EVAL/UN_AVL`) x **busy?** x **has in-flight update?** are
+  orthogonal. `syn_0/20/50` are 2-state (no AVL_EVAL); `_trace_has_avl_eval` guard collapses D.2 for them.
 
 ---
 
-## 1. Core decisions (all resolved)
-
-### The source of truth is PER-BASELINE — the asymmetry IS the design
-- **Availability-UNAWARE (oort, refl):** real trainers go unavailable and **do not notify**; the
-  oracular aggregator **reads the traces**. So **A/B are the FAITHFUL model here, not a shortcut** —
-  real oort has no notification channel. The oracle gates **new selection only** (Q-new-1): it never
-  proactively evicts an in-flight trainer (it has no way to know), it just waits for the withheld
-  update to arrive on return.
-- **Availability-AWARE (felix, fluxtune):** the aggregator does **not** read traces; it is informed
-  by **trainer→agg notification events** that **must take effect immediately** at the aggregator and
-  factor into selection AND `selected_ends`. So **C is the faithful model here**, with the
-  frozen-clock defect fixed.
-- **One trace + one `state_at(trainer, vclock)` resolver + one effect path** shared by both, so
-  "what the agg believes" and "what the trainer is" cannot disagree. The only per-baseline difference
-  is *how the agg learns* a transition (oracle read vs event) and *whether* it acts on it (`awareness`
-  flag). **agg awareness** (does it factor availability in?) is orthogonal to **how it learns**.
-
-### Stop-gap for the aware path (Q4)
-Model the aware event as **instant oracular reflection at the agg** (agg reads the shared trace on
-the vclock at the transition instant, zero lag — behaviorally equal to instant push for selection).
-**End goal = the true `avl_*` trainer→agg message.** Architecture must keep the
-state-resolution + effect logic identical so the future swap changes only *transport*, not *effect*
-(extensibility is a hard requirement). Per-tick broadcast (agg pings everyone each step) is
-**rejected** (comms-heavy, induces sub-optimal decisions).
-
-### Mid-flight unavailability = COMPLETE-then-WITHHOLD-then-DELIVER (not a lost update)
-When a trainer goes `UN_AVL` mid-compute it **finishes local compute, withholds the result, and
-delivers it (now stale) on return to an available state.** Delayed delivery, not cancellation:
-- Sim holds the completed update at `sct` but gates *delivery* on the next `AVL_*` window:
-  **`delivery_ts = max(sct, next_avail_ts)`**; it commits as a **stale** contribution (feeds
-  Stage-5/6 staleness, not a lost-update path).
-- **AWARE agg:** on the `UN_AVL` event, **frees the slot** (replacement selectable) AND **tracks the
-  pending withheld delivery separately** (two ledgers — see Challenge 4).
-- **UNAWARE agg:** no replacement; just waits for the delayed delivery.
-- Late withheld update on return (Q-new-2): **async aware (felix) = accept-stale** through the
-  baseline's existing staleness path; **sync (feddance) = reject if staleness exceeds the baseline's
-  (lower) tolerance** — reuse the existing threshold, do NOT invent a new scalar.
-- **Distinct from "busy"** (PARITY.md dead-end: do NOT route busy→`UN_AVL`). Busy = `AVL_*` but
-  occupied (hold slot, returns on time). Withheld = result exists, delivery deferred. Separate states.
-
-### Timing, comms, determinism
-- **Transitions are continuous / event-scheduled at the exact transition vclock**, reflected at the
-  aware agg **immediately (lag = 0 first cut)** — not sampled-at-selection (a mid-round transition
-  must take effect mid-round). The clock-advance/commit path must consult the **next transition time**
-  so it can't skip a mid-window change: clamp the advance to `min(next_sct, next_transition_ts)`.
-- If lag is ever modeled it lives on the **vclock** (per the §S.dur lesson: selector-fed quantities
-  must be intrinsic, never wall-contaminated).
-- Oracular-pull is deterministic given trace+clock. The event path stays deterministic too (first cut
-  = instant oracular reflection); the true-message path must order events by vclock with a defined
-  tie-break to preserve `SEED=1234` real+sim parity (Challenge 6).
-- **Everything config-gated, default OFF** ⇒ byte-identical to today's 46/46 scoreboard. Per-baseline
-  `availability_aware: bool` + `availability_trace: <name>` + master `sim_unavailability` gate.
-
-### Trace representation
-- Collapse to **one event-trace representation** (`AVL_TRAIN/AVL_EVAL/UN_AVL`, strictly more
-  expressive than duration-windows; derive windows if a path still needs them). **Prefer 3-state
-  traces**; 2-state ({avail, unavail}) is allowed but **limited-utility for aware baselines**
-  (felix/fluxtune act on the `AVL_TRAIN↔AVL_EVAL` task-type split a 2-state trace collapses; oort is
-  indifferent). Surface trace granularity in telemetry.
-- Single-source the trace + resolver like `client_duration.py` was single-sourced in §S.dur; both the
-  trainer side (transitions/telemetry) and agg side (oracular driver) read the identical object.
-  Traces (`mobiperf_2st/3st`, `syn_0`=100%, `syn_20`, `syn_50`) cover all n=300, loaded identically
-  both sides (Q-new-3).
+## Parity rungs (availability tier -- what exists)
+
+- **A1** `avail_composition` (per-state counts, binned). **A3** `trace_time_base_consistency` -- CONTROL
+  hard gate (dep K3). **A4** `per_trainer_duty_cycle`. **A4dur** duration-weighted TVD
+  (`mean_err<=0.05`, `frac_within_tol(0.10)>=0.95`). **A5** `state_timeline_agreement` -- per-(trainer,t)
+  exact match. All five are **relative** (real vs sim).
+- **A6** `trainer_trace_fidelity`, **A7** `agg_belief_fidelity` (tagged `selection`/`commit`), **A8**
+  `send_gate_wait_fidelity` (real-mode only) -- **absolute** (vs. ground-truth trace), independently per
+  mode. A7 is mechanism-agnostic (trace_read now, client_notify/predictive later).
+- **K11** `commit_promptness` (INV) -- per-event: actual commit vs. earliest-legally-committable time,
+  generic over gate reason; primary promptness gate. `withheld_delivery` / `abandon_timeout` stay as
+  secondary distributional diagnostics.
+- **eligible_pool_reduction** (`Aa`, HELD), **observation_lag** (live in v1 trace_read via A7),
+  **starvation_advance** (vclock jumps under scarcity). Calibrate HELD rungs at mobiperf.
+- **Ramp:** syn_0 -> syn_20 -> syn_50 -> mobiperf_*.
 
 ---
 
-## 2. First-principles factors (the why behind each decision)
-
-- **F1 Clock authority.** One monotonic vclock owns "now"; every availability decision is indexed by
-  it, never wall, never a per-trainer frozen clock. The trace is **sim-seconds since run start**; sim
-  (vclock) and real (wall-elapsed) must index the SAME windows — this is parity rung **A3** (the REFL
-  HIGH-1 hazard), a CONTROL for the whole feature.
-- **F2 Source of truth** — per-baseline (§1). Both models share one trace + one resolver + one effect.
-- **F3 Event semantics (what a transition CAUSES).** `→UN_AVL` aware: excluded from selection AND
-  freed from `selected_ends`/`all_selected` (`channel.update_state`), in-flight update withheld not
-  discarded. `→UN_AVL` unaware: agg waits (no proactive free). `AVL_TRAIN→AVL_EVAL`: train-pool
-  removal, eval-eligible only. `→AVL_TRAIN`: re-enters pool + triggers withheld delivery. The driver
-  must produce these effects deterministically at the transition instant, not merely filter the next
-  selection.
-- **F4 Withhold-then-deliver** (§1). Return-stage fates: on-time / straggler-hold / withheld-then-
-  delivered. NO permanent cancellation. `_sim_hold_busy_slots` and oort `pending_after`/carry-over
-  must keep a withheld end accounted until its delayed delivery commits.
-- **F5 Comms** — unaware: zero (oracular pull); aware: bounded by # real transitions (instant
-  reflection first cut), per-tick broadcast rejected.
-- **F6 Timing** — continuous/event-scheduled, lag 0 first cut (§1).
-- **F7 Regression surface (won mechanisms).** §3.resid `_sim_hold_busy_slots` (aware frees slot +
-  tracks pending; unaware holds until delivery); §4.5 `pending_after` / §4.9 carry-over (withheld end
-  must NOT re-enter pool during the down window, but its delivery must still commit, stale); §S.pacer
-  /§S.dur/A2c selector inputs (fewer candidates move the `pref` percentile — expect A2/S2/A2c shift;
-  score only genuinely-eligible trainers); per-baseline return stages each gain a "trainer vanished"
-  branch. All config-gated ⇒ default-off keeps byte-identity.
-- **F8 Determinism** — oracular-pull seed-stable; event path ordered by vclock (Challenge 6).
-- **F9 Trace** (§1).
-- **F10 Starvation.** `oort/top_aggregator` already has a `max_retries` wait-retry for too-few-
-  available; under real unavailability it fires. In sim the wait must **advance the vclock** (jump to
-  next availability event / next in-flight `delivery_ts`), not spin on wall (Stage F).
+## Challenges / land-mines (durable -- consult before the fwdllm port)
+
+Most are resolved; the still-open ones (3, 15) matter for cross-baseline validation and the port.
+
+1. Ordering on `delivery_ts`, not `sct` -- resolved (U6/U3 validated).
+2. A3 time-base drift -- resolved; hard CONTROL gate; 90s abandon re-clocked to vclock.
+3. **A2 two-tolerance trap (OPEN, watch).** Bimodal sim vs smoother real -> KS shape artifact; means match;
+   improving with run length (0.437->0.338). Expect <=0.2 at n=300/3h -- confirm at T5.
+4-14. Resolved: busy/unavail/withheld three ledgers (4); real send-gate fidelity (5); determinism via
+   `(delivery_ts,end_id)` (6); compound straggler x UN_AVL (7); AVL_EVAL inert for oort + `_trace_has_avl_eval`
+   guard (8); staleness-on-sync cohort movement (9); scarcity advance skips no events (10); syn_0
+   byte-identity discipline (11); library mixin spans examples, never example-local (12); empty per-task
+   pool corrupting `selected_ends` -- fixed by keying cleanup off `connected_ends` in all 3 selectors,
+   **still needs live mobiperf_3st exercise** (13); scarcity threshold via F.2 unified pattern (14).
+15. **Per-baseline in-flight accounting + scenario sizing (OPEN, per-baseline).** In-flight is NOT constant:
+    oort (sync, over-selects) `in_flight ~= overcommitment*agg_goal - completed`; felix/fedbuff (async)
+    concurrency-bound, can exceed agg_goal; refl/feddance (sync FedAvg) clear `selected_ends` each round,
+    feddance returns *partial* selections so `eligible ~= (1-unavail)*n`. Manage in-flight per baseline; do
+    NOT assume "sync has no in-flight term." syn_50 caps ~43% unavail, so feddance's straddle window is
+    narrow (n~19) -- size `n ~= threshold / (1-unavail_frac)`.
+16-18. Resolved: real syncfl recv-barrier bounded `timeout=min(90s,budget)` (B2.0.1, 16); sim starvation
+   self-termination `>`->`>=` budget check (B2.0.2, 17); real-mode trace-clock join-ramp re-anchor
+   (B2.0.3, 18) -- correct, but was masking item 20.
+19. Resolved (Batch 4): oort/felix `K6 sim_send_ts` -- sim `Trainer._sim_now()` froze at last dispatch;
+   fixed via due-ts stamping + EOT final wake-up. K6/A6 PASS on the felix n=300 run.
+20. Resolved (Batch 3 T3.1a): `debug_run.sh` never wired the trainer's own `client_notify.trace`, so real
+   trainers ran their send-gate against always-available `syn_0` regardless of `--trace` (sim was
+   aggregator-driven, so unaffected). Fixed + regression-tested
+   (`tests/launch/test_debug_run_trace_substitution.py`). This was the true cause behind the feddance A3/K3b
+   symptoms earlier blamed on clock-origin.
 
 ---
 
-## 3. Concepts to keep crisp (naming discipline, PARITY.md)
+## Dead-ends (settled -- do not retry)
 
-- **availability state** (`AVL_TRAIN/AVL_EVAL/UN_AVL`) × **busy/occupied?** × **has in-flight update?**
-  — three orthogonal axes, never conflate (the busy→UN_AVL dead-end).
-- **transition instant** (vclock the state changes) vs **observation instant** (vclock the agg acts);
-  lag = observation − transition (0 if continuous).
-- Return fates: on-time / straggler-hold / withheld-then-delivered (stale). No cancellation.
-- **agg awareness** ⊥ **how it learns** (oracle read vs event message).
-- `_sim_now()` must stop meaning "last dispatch ts" — availability reads the **global vclock** (or is
-  fully agg-driven so the trainer never needs `_sim_now` for it).
+- **busy -> UN_AVL routing** -- three distinct states.
+- **Frozen per-trainer clock** (`_sim_now()` = last-dispatch ts) -- stuck UN_AVL forever; read `_vclock.now`.
+- **Wall-clock in sim** for selection gate / 90s abandon -- wall barely advances vs vclock.
+- **Per-tick MQTT broadcast** -- comms storm; v1 = trace-read pull (zero comms).
+- **Ordering withheld commits by `sct`** -- past-dating; order by `(delivery_ts, end_id)`.
+- **Forking withhold/abandon per stack** -- single shared `ClientAvailability`.
+- **A4 bare transition fraction** -- brittle in trace-read mode; replaced by A4dur + Aa.
+- **D.2 excluding AVL_TRAIN from eval on 2-state traces** -- empty eval pool wiped `selected_ends`; fixed by
+  `_trace_has_avl_eval` guard.
+- **Subtracting starvation vclock-jumps from the budget** -- breaks parity (real polls scarcity on wall
+  budget; sim vclock jump consumes virtual budget symmetrically). Size `--runtime-s` accordingly.
 
 ---
 
-## 4. New parity rungs (Stage 2 = Availability; extend the ladder)
-
-Each new mechanism leaves the finest-grained check that localizes it (PARITY.md Growth rule).
-- **A1 avail_composition** (exists, trivial at 100%): now match per-state counts over the run, binned.
-- **A3 trace_time_base_consistency** `[NEW]` (CONTROL/DIST, dep K3): same trace → same windows both
-  modes. **Hard gate — do not read A1/A2/A4 until A3 passes** (the REFL HIGH-1 / Challenge 2 lesson).
-- **A4 per_trainer_duty_cycle** `[NEW]` (MECHANISM/DIST, dep A3): on/off fraction per trainer matches.
-- **transition_effect** `[NEW]`: counts of UN_AVL slot-frees (aware), withheld-then-delivered updates,
-  AVL_TRAIN→AVL_EVAL demotions; sim vs real.
-- **withheld_delivery** `[NEW]`: dist of `delivery_ts − sct` (down-window delay) + resulting staleness
-  (cross-checks F4 against Stage-5/6 U3).
-- **observation_lag** `[NEW]`: transition→effect lag (tests F6; **must be ≈0** first cut for aware).
-- **eligible_pool_reduction** `[NEW]`: A2 (`num_eligible`) tracks real's reduction, not just at 100%.
-- **Regression guard:** re-run the syn_0 90-min all-baseline parity with availability OFF → current
-  scoreboard byte-for-byte (config-gating proof).
-- **Ramp:** `syn_0` (regression) → **`syn_20` (first validation target)** → `syn_50` → `mobiperf_*`.
-  Shortest run per effect (run-length budget table); reserve long runs for C1/C2. First mechanism pass
-  = 45-min "one rung" budget, 5-min smoke first.
+## Known parity failures (non-blocking -- resolve at T5 with long-run data)
+
+Resolved this project (full detail in git / §7 history): A4dur (all baselines, real selection missing
+`vclock_now` -> fixed, `mean_err=0.0`); feddance A3 (item 20); K6/A6/A7-commit/asyncfl-TIMEOUT (Batch 4,
+confirmed on felix n=300). Still open, for the parallel-branch campaign:
+
+| Check | Baseline | Status |
+|---|---|---|
+| A2 `eligibility` KS | oort | 0.437->0.338 (1.5h->3h); FAILs @ syn_20 n=300 short. Bimodal-vs-smooth shape; means match. Investigate with A4dur. |
+| A2 `eligibility` KS | feddance | FAILs @ syn_20 n=300 smoke; earlier "clears at n=300" (n=25) not confirmed -- re-open. |
+| K3b `overhead_residual` | oort | rel~=0.116; run-length sensitive; P3 gates at n=300. |
+| P3 `trainer_speed` | oort | ratio=1.153 (tol 1.15); marginal tail at n=300; gates K3b. |
+| `throughput` | oort | FAILs @ syn_20+syn_50 n=300 smoke; baseline-specific, lower priority. |
+| `avail_composition`/`commit_visibility`/`total_commits` | fedbuff | FAILs @ syn_20 n=300 smoke -- but see fedbuff confound (Status); re-check after isolated re-run. |
+| C2 `loss` | feddance | avg_diff~=0.16 (few eval pts); early-training noise at alpha=0.1; K8/C1/utility PASS. |
+| U5 `inter-arrival` rho | feddance | 0.659->0.381 (syn_20->50); watch at mobiperf. |
 
 ---
 
-## 5. Staged implementation + testing plan
-
-One mechanism per stage, each gated by its own tests + a syn_0 byte-identity regression + (where it
-changes dynamics) a short syn_20 run. All config-gated, default OFF. Build the **unaware** (oort,
-pure pull) path before the **aware** (felix, event+eviction+withhold) path — strictly simpler, shares
-the substrate. Context-free names (`_ts`/`_time_s`, `_round`).
-
-### Stage A — Substrate: one trace, one resolver, one clock (NO behavior change)
-- **A.1** New `flame/availability/trace.py` (mirrors `client_duration.py`): `load_trace(trainer_id) →
-  SortedDict[ts→state]` and `state_at(trace, t) → TrainerAvailState` (the binary-search currently
-  inlined in `get_curr_unavail_trainers` / `oracular_trainer_avail_check` / trainer
-  `check_and_update_state_avl`). Replace all three call sites; collapse `trainer_unavail_durations`
-  onto the event-trace.
-- **A.2** Config surface: per-baseline `availability_aware`, `availability_trace`, master
-  `sim_unavailability` (default False). `syn_0` ⇒ no UN_AVL events ⇒ inert even when on.
-- **A.3** Fix `_sim_now()` frozen clock (F1/F8): trainer availability reads the **global vclock**, not
-  `_sim_send_ts`. Route: make availability fully agg-driven; agg stamps the current vclock onto every
-  message the trainer receives, trainer uses that as "now" for its notification telemetry.
-- **A.4** Telemetry (on the vclock): `avail_change` (move off wall), `agg_observed_state` (per-trainer
-  belief at each selection), trace granularity per run.
-- **Tests:** resolver determinism + parity with the old inlined searches; frozen-clock deadlock cannot
-  recur; `sim_unavailability=False` ⇒ byte-identical. **Exit:** syn_0 90-min all-baseline parity holds
-  the scoreboard byte-for-byte.
-
-### Stage B — A3 time-base CONTROL (gate for everything above it)
-- **B.1** A3 `trace_time_base_consistency` (CONTROL/DIST, dep K3): resolved on/off windows align
-  between modes within tolerance. **B.2** A4 `per_trainer_duty_cycle` (dep A3).
-- **Tests + a 5-min syn_20 smoke** to populate A3/A4 (checker-side, validates instantly vs stored
-  dirs). **Exit:** A3 PASS on a syn_20 smoke for oort.
-
-### Stage C — UNAWARE oracular-pull driver (oort, refl)
-- **C.1** Activate `get_curr_unavail_trainers()` for oort/refl via the Stage-A resolver on
-  `_vclock.now` → `channel.set_curr_unavailable_trainers`. **Gates new selection only** (Q-new-1).
-- **C.2** Withheld-then-deliver for the pull path: an in-flight trainer entering `UN_AVL` is **not**
-  evicted; its modeled update is held and delivered at `delivery_ts = max(sct, next_avail_ts)`,
-  committing **stale**. Held end must NOT re-enter the pool during the down window (extend §4.5
-  `pending_after`: exclude on `vclock < delivery_ts`, not just `< sct`).
-- **C.3** Ordering: drain/commit order must key on **`delivery_ts`** for held ends (a withheld delivery
-  has `delivery_ts > sct`), or past-dating reappears (Challenge 1).
-- **Tests:** unaware never frees the in-flight slot; withheld delivers at `max(sct,next_avail)`,
-  commits stale; held end excluded until delivery; determinism.
-- **Validation:** syn_20, 45-min, oort+refl. Read A1, A2 (eligible-pool reduction), A4, withheld-delay
-  dist + staleness (U3). **Exit:** A1/A2/A3/A4 PASS, no new past-dating (U6), K2/K3b hold vs a syn_20
-  real reference.
-
-### Stage D — AWARE immediate-event driver (felix; fluxtune if in scope)
-- **D.1** Instant reflection: at every selection AND at each transition vclock the agg recomputes
-  per-trainer state from the resolver (stop-gap for the push message); effect path identical to a real
-  `avl_*` message (future swap = transport only).
-- **D.2** Continuous/event-scheduled timing (F6): advancing the vclock toward the next commit, clamp to
-  `min(next_sct, next_transition_ts)` so a mid-window `UN_AVL` takes effect before the in-flight `sct`.
-- **D.3** UN_AVL eviction + reselect: free the slot from `selected_ends`/`all_selected` (reuse
-  `channel.update_state` logic), make a replacement selectable, AND register the withheld delivery
-  separately (`pending_withheld[end]=delivery_ts`). Reconcile with §3.resid `_sim_hold_busy_slots` —
-  slot freed *and* pending delivery tracked, no leak, no double-count (Challenge 4).
-- **D.4** `AVL_TRAIN↔AVL_EVAL`: task-type eligibility change via the resolver; only meaningful where
-  the baseline dispatches eval (sync oort dispatches 0 — felix-relevant; flag inert baselines,
-  Challenge 8).
-- **D.5** Late withheld update = accept-stale (async) through felix's existing staleness path (no new
-  accept path; Q-new-2 async branch).
-- **Tests:** UN_AVL frees slot + tracks pending (no leak); replacement selectable; event-scheduled
-  clamp fires a mid-window transition before the straggler's sct; AVL_EVAL gates task type; late update
-  commits stale.
-- **Validation:** syn_20, 45-min, felix. A1/A2/A3/A4, transition-effect counts vs real, observation_lag
-  ≈0, withheld-delivery, U3, U6. **Exit:** mechanism rungs PASS at syn_20; then a full-length run to
-  re-confirm felix C1/C2 under unavailability.
-
-### Stage E — SYNC baselines + staleness-gated rejection (feddance)
-- **E.1** Apply C/D to the sync path (feddance is availability-aware via its predictor; barrier
-  re-selects the cohort each round).
-- **E.2** Staleness rejection: a late withheld update exceeding feddance's tolerance is **dropped**
-  (baseline's existing rule, no new threshold). Changes round composition → expect K8/U2 movement;
-  validate it's faithful (Challenge 9).
-- **E.3** §6.u6 barrier-anchor: unavailability changes which K form the barrier; the barrier-anchored
-  U6 lag must be computed over the *actually contributing* cohort.
-- **Tests + syn_20 45-min feddance.** **Exit:** A-rungs + U3/U6 + K8 PASS.
-
-### Stage F — Starvation / clock-advance under scarcity (F10)
-- **F.1** In the `max_retries` wait-retry, when no one is selectable, **advance the vclock to the next
-  availability event (or next in-flight `delivery_ts`)** rather than wall-sleeping. Clamp to the
-  nearest of {next transition, next `delivery_ts`, next `sct`}; guard against an all-unavailable window
-  spinning forever (Challenge 10).
-- **Validation:** syn_50, 45-min (heavier unavailability triggers scarcity), all baselines. **Exit:**
-  no stalls; K1 monotone; round cadence faithful at syn_50.
-
-### Stage G — Ladder integration + ramp + sign-off
-- **G.1** Land all new rungs in `scripts/parity/{checks.py,report.py}` with deps (A1 now enforced, A3,
-  A4, transition_effect, withheld_delivery, observation_lag, eligible_pool_reduction). Append-only.
-- **G.2** Ramp: syn_0 → syn_20 → syn_50 → mobiperf_*. **G.3** Per-baseline sign-off, now *with*
-  availability.
-
-### Stage H (FUTURE) — true `avl_*` message transport
-Swap the aware-path instant-oracular reflection for real trainer→agg `avl_*` messages, processed
-immediately, **without changing the effect logic** (D.1 was built for this). Preserve determinism by
-ordering events on the vclock with a defined tie-break (Challenge 6).
+## Open items -- pick up in order
+
+1. **Legacy `trackTrainerAvail` cleanup (oort/oort_star/refl) -- flagged, NOT done.** Their `baselines.yaml`
+   entries still carry `trackTrainerAvail: {enabled: True, type: ORACULAR}`. In every `debug_run.sh
+   --trace` run this resolves to the same `simUnavailability=True` path (a substitution quirk, not a static
+   value). Do **not** just zero `enabled`/`type` -- that risks silently disabling availability for any
+   invocation not going through the substitution script. Safe path: (a) add `simUnavailability: true`
+   statically wherever their trace is set; (b) only then zero the legacy block; (c) verify via an actual
+   generation + short real run (no pytest coverage of `debug_run.sh`'s generator).
+2. **Minimal mobiperf live exercise before "mature enough to port."** The entire mobiperf (3-state,
+   AVL_EVAL) path is untested live so far (only syn_0/20/50, which are 2-state and collapse AVL_EVAL away).
+   Challenge 13's fix explicitly still needs live exercise at mobiperf_3st. ~30-45 min for one async
+   (felix) + one sync (refl or oort_star) baseline exercises AVL_EVAL + the empty-pool cleanup live and runs
+   Batch 3's checks against a 3-state trace.
+3. **PR workflow.** felix is confirmed (62/62). Gated for a felix+fedbuff PR on the fedbuff isolated re-run +
+   concurrent-run investigation (Status). The fwdllm learnings are now carried into
+   [../fwdllm/simulate_fwdllm.md](../fwdllm/simulate_fwdllm.md) and [PARITY.md §F](PARITY.md); the design
+   decisions kept (this doc's v1 decisions / land-mines) and rejected (Dead-ends) are the durable record.
+
+### Minimal bar before porting fwdllm (not a full T5 gate)
+Don't gate the port on the full 3h x 6-baseline x 4-trace campaign (that's for paper-quality numbers). Bar:
+(1) Batch 3 (T3.0-T3.5) at least through felix -- **done** (A4dur confirmed; item 20 fixed; absolute
+fidelity checks live). (2) mobiperf_2st for one async + one sync baseline (~30-45 min) to exercise AVL_EVAL
++ Challenge 13's cleanup live for the first time. (3) The full syn_50/mobiperf 6-baseline sweep is
+separable -- parallel branch, not a pre-port blocker.
 
 ---
 
-## 6. Challenges / land-mines
-
-1. **Ordering must key on `delivery_ts`, not `sct`, for withheld updates** (high risk of
-   re-introducing past-dating). §3.drain's min-`sct` gate and §4.9 carry-over assume `commit order ==
-   sct order`; a withheld delivery commits at `max(sct,next_avail) > sct`. Re-validate U6/U3 after C/D.
-2. **A3 time-base drift is the silent killer.** If sim vclock and real wall-elapsed advance at
-   different rates, the same trace makes a trainer unavailable at different real moments → every higher
-   rung diverges and mislocalizes. Hard CONTROL gate; do not read A1/A2/A4 until A3 passes.
-3. **Two-tolerance trap on the eligible pool (A2 vs S3/4).** With availability ON,
-   `eligible = candidates − in_flight − unavailable`; a small gap can fail A2's tight KS while S3/4
-   in_flight passes. Decompose the channel first; don't chase A2 as a separate bug.
-4. **Busy vs unavailable vs withheld = three distinct non-pool states** (slot-leak / N≈300 ramp). The
-   §3.resid dead-end (busy→UN_AVL) ramped in-flight to ~300. Aware UN_AVL **frees** the slot but still
-   **tracks** the pending delivery — slot accounting and delivery accounting are separate ledgers;
-   conflating them leaks slots or double-commits.
-5. **Stop-gap fidelity to real felix may not be lag-free.** Real felix uses MQTT notifications with
-   real delivery+processing lag; the stop-gap models lag 0. If real's lag is non-trivial,
-   `observation_lag` parity (sim 0 vs real >0) diverges and selection contexts won't match. Measure
-   real's notification lag early; if material, model it on the vclock or accelerate Stage H (the §S.dur
-   lesson: don't let a wall lag contaminate a vclock-indexed decision).
-6. **Determinism / event tie-break at a shared vclock instant.** Transition, commit, and selection
-   events can coincide. Define a total order (e.g. transitions < commits < selections, then by
-   trainer_id) so `SEED=1234` real+sim parity + exact rungs stay enforceable.
-7. **Compound states with existing carry-over.** An oort §4.9 carried-over straggler that ALSO goes
-   UN_AVL, or a §3.resid held slot whose trainer flips AVL_TRAIN→AVL_EVAL, are real cases. Enumerate
-   the (avail_state × occupied × in-flight) cross-product and assert each cell in tests.
-8. **AVL_EVAL may be inert for some baselines** (sync oort dispatches 0 eval). A 3-state trace's eval
-   windows then do nothing; report which baselines exercise the eval split (ties to the 2-state
-   limited-utility flag, F9).
-9. **Staleness-rejection on sync changes round composition (feddance).** Dropping over-stale late
-   updates shifts K8/U2/round-count — expect movement, validate it's faithful, reuse the existing
-   threshold (no new scalar).
-10. **Scarcity clock-advance must not stall or fast-forward past events** (F10/Stage F). Clamp the jump
-    to the nearest of {next transition, next `delivery_ts`, next `sct`} and terminate on an
-    all-unavailable window. Guard K1 monotone + the K5 failsafe ceiling.
-11. **Regression discipline.** Every stage re-runs the syn_0 90-min all-baseline parity and must hold
-    the scoreboard byte-for-byte before its syn_20 validation counts. A stage perturbing another
-    baseline serializes (one baseline per run round).
+## Stage H (future -- out of scope)
+
+Two independent knowledge-model upgrades, both replacing `trace_read` on the `tracking_mode` axis; the
+effect logic (select-filter / in-flight-evict) is unchanged -- only how the agg learns state changes:
+- **H.1 Message-transport** (`client_notify` ON for aware baselines): trainers push avl-state changes over
+  MQTT instead of the agg reading the trace + a continuous/event-scheduled vclock clamp. Re-measure
+  `observation_lag` (must be ~0) once live. (fwdllm's fluxtune baseline already configures `client_notify`
+  -- see simulate_fwdllm.md D1.)
+- **H.2 Predictive**: a learned/heuristic availability model (no trace read or message push). Not designed yet.
 
 ---
 
-## 7. Open follow-ups (note here as work lands)
+## History (collapsed -- full detail in git)
 
-- **Q-new-2 sync confirmation:** verify feddance's existing staleness threshold is the right rejection
-  gate on a real syn_20 run before E.2 (don't assume the async tolerance transfers).
-- **Real notification lag (Challenge 5):** measure on a real felix run early; decides whether lag 0 is
-  admissible or Stage H must move up.
-- *(Append new open questions/info needs here as the substrate lands — keep this the single ledger.)*
+- **A-G, C.6, D, E, F.2, B2.0.x, T0-T5, Batch 2/3/4** all landed. Substrate + A3 time-base CONTROL,
+  send-gate/deliver-late, two-ledger, proactive evict (felix), syncfl path, starvation self-termination,
+  the absolute ground-truth fidelity checks (Batch 3 T3.0-T3.5: A6/A7/A8/K11 + `ground_truth.py` + shared
+  canonical time origin), and Batch 4's four gating fixes (asyncfl real self-stop, sim trainer-clock freeze
+  / K6 / A6, A7-commit checker `max_gap_s`) are all in code + tests, confirmed on the felix n=300 run.
+  Per-task mechanism/file/exit detail lives in commit history; the durable decisions are in "v1 core
+  decisions", "Challenges", and "Dead-ends" above.
diff --git a/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py b/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py
index bfa3d6312..f8a7739d2 100644
--- a/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py
+++ b/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py
@@ -119,25 +119,9 @@ def __init__(
         self.learning_rate = self.config.hyperparameters.learning_rate
         self.batch_size = self.config.hyperparameters.batch_size or 16
 
-        self.track_trainer_avail = (
-            self.config.hyperparameters.track_trainer_avail or None
-        )
         self.reject_stale_updates = (
             self.config.hyperparameters.reject_stale_updates or False
         )
-        self.trainer_event_dict = None
-        if (
-            self.track_trainer_avail["enabled"]
-            and self.track_trainer_avail["type"] == "ORACULAR"
-        ):
-            self.trainer_event_dict = self.read_trainer_unavailability(
-                self.track_trainer_avail["trace"]
-            )
-        else:
-            print(
-                f"Did not read oracular trainer jsons. Enabled value: {self.track_trainer_avail['enabled']}, type: {self.track_trainer_avail['type']}, trace: {self.track_trainer_avail.get('trace', '<unset>')}"
-            )
-        print("self.trainer_event_dict: ", self.trainer_event_dict)
 
         self.loss_list = []
 
@@ -155,18 +139,6 @@ def initialize(self):
             _os.path.join(_os.path.dirname(_os.path.abspath(__file__)),
                           "..", "..", "data"))
 
-    def read_trainer_unavailability(self, trace=None) -> None:
-        """
-        Read availability trace pattern from central trace file.
-
-        Currently returns None to disable oracular pre-loading.
-        The selector can still access traces via availability_trace_file config.
-
-        This allows the aggregator to work with dynamic trainer spawning
-        without hardcoding the number of expected trainers.
-        """
-        return None
-
     def load_data(self) -> None:
         """Load a test dataset."""
         transform_test = transforms.Compose(
diff --git a/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py b/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py
index 46ddbd794..f733093b1 100644
--- a/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py
+++ b/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py
@@ -22,14 +22,12 @@
 
 import logging
 import time
-from pathlib import Path
 
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 import torchvision
 import torchvision.transforms as transforms
-import yaml
 
 # wandb setup
 import wandb
@@ -41,15 +39,6 @@
 import sys as _sys, os as _os
 _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
 from oracle_utility import OracleInjectMixin  # noqa: E402
-from sortedcontainers import SortedDict
-
-
-_METADATA_DIR = (Path(__file__).resolve().parents[3] / "_metadata")
-_TRACE_KEY_TO_MOBIPERF_SUB = {
-    "mobiperf_2st": "states_2st",
-    "mobiperf_3st_50": "states_3st_50",
-    "mobiperf_3st_75": "states_3st_75",
-}
 
 
 def initialize_wandb(run_name=None):
@@ -130,26 +119,6 @@ def __init__(
         self.learning_rate = self.config.hyperparameters.learning_rate
         self.batch_size = self.config.hyperparameters.batch_size or 16
 
-        self.track_trainer_avail = (
-            self.config.hyperparameters.track_trainer_avail or None
-        )
-        self.trainer_event_dict = None
-        if (
-            self.track_trainer_avail["enabled"]
-            and self.track_trainer_avail["type"] == "ORACULAR"
-        ):
-            self.trainer_event_dict = self.read_trainer_unavailability(
-                self.track_trainer_avail["trace"]
-            )
-        else:
-            print(
-                "Did not read oracular trainer jsons. "
-                f"enabled={self.track_trainer_avail.get('enabled')}, "
-                f"type={self.track_trainer_avail.get('type')}, "
-                f"trace={self.track_trainer_avail.get('trace', '<unset>')}"
-            )
-        print("self.trainer_event_dict: ", self.trainer_event_dict)
-
         self.loss_list = []
 
         # Use wandb logging if enabled
@@ -166,63 +135,6 @@ def initialize(self):
             _os.path.join(_os.path.dirname(_os.path.abspath(__file__)),
                           "..", "..", "data"))
 
-        # Initialize aggregator start time for oracular availability tracking
-        self.agg_start_time_ts = time.time()
-        logger.info(f"Aggregator initialized at timestamp: {self.agg_start_time_ts}")
-
-    def read_trainer_unavailability(self, trace=None) -> dict:
-        """Build trainer_id -> SortedDict(timestamp -> state) for `trace`.
-
-        Reads from the shared examples/_metadata/ bundle (registry + traces),
-        not from legacy per-trainer JSON files.
-        """
-        logger.info(f"Reading trainer unavailability for trace: {trace}")
-
-        registry_path = _METADATA_DIR / "trainer_registry.yaml"
-        with open(registry_path) as f:
-            registry = yaml.safe_load(f)["trainers"]
-
-        if trace in _TRACE_KEY_TO_MOBIPERF_SUB:
-            sub = _TRACE_KEY_TO_MOBIPERF_SUB[trace]
-            with open(_METADATA_DIR / "availability_traces/mobiperf_traces.yaml") as f:
-                traces = yaml.safe_load(f)["traces"]
-
-            def lookup(tk: str, trainer_id: int) -> list:
-                return traces[f"device_{trainer_id:03d}"][sub]
-
-        elif trace and trace.startswith("syn_"):
-            with open(_METADATA_DIR / "availability_traces/synthetic_traces.yaml") as f:
-                syn = yaml.safe_load(f)["traces"]
-            if trace not in syn:
-                logger.warning(f"trace {trace!r} not found in synthetic_traces.yaml")
-                return None
-            entry = syn[trace]
-            per_trainer = entry.get("per_trainer", {}).get("n300", {})
-            pattern = entry.get("pattern", [])
-
-            def lookup(tk: str, trainer_id: int) -> list:
-                return per_trainer.get(tk) or pattern
-
-        else:
-            logger.warning(f"unsupported trace name: {trace!r}")
-            return None
-
-        trainer_events_dict = {}
-        for tk, meta in registry.items():
-            trainer_id = meta["trainer_id"]
-            task_id = meta["task_id"]
-            events = lookup(tk, trainer_id)
-            state_dict = SortedDict()
-            for timestamp, state in events:
-                state_dict[timestamp] = state
-            trainer_events_dict[task_id] = state_dict
-
-        logger.info(
-            f"Loaded availability traces for {len(trainer_events_dict)} trainers "
-            f"(trace={trace})"
-        )
-        return trainer_events_dict
-
     def load_data(self) -> None:
         """Load a test dataset."""
         transform_test = transforms.Compose(
@@ -295,41 +207,6 @@ def _job():
         import threading
         threading.Thread(target=_job, daemon=True).start()
 
-    def get_curr_unavail_trainers(self) -> list:
-        """Return trainer IDs currently in UN_AVL state based on oracular traces."""
-        curr_unavail_trainer_list = []
-
-        if self.trainer_event_dict is None:
-            return curr_unavail_trainer_list
-
-        agg_time_since_start_s = time.time() - self.agg_start_time_ts
-
-        for trainer_id, event_dict in list(self.trainer_event_dict.items()):
-            if not event_dict:
-                continue
-
-            idx = event_dict.bisect_right(agg_time_since_start_s) - 1
-            if idx >= 0:
-                most_recent_event = event_dict.peekitem(idx)
-                most_recent_event_ts = most_recent_event[0]
-                most_recent_event_state = most_recent_event[1]
-
-                if most_recent_event_state == "UN_AVL":
-                    curr_unavail_trainer_list.append(trainer_id)
-                elif most_recent_event_state == "AVL_TRAIN":
-                    pass
-                else:
-                    logger.warning(
-                        f"Trainer {trainer_id} has unknown state: {most_recent_event_state}"
-                    )
-        
-        logger.info(
-            f"[ORACULAR] Current unavailable trainers: {len(curr_unavail_trainer_list)} "
-            f"out of {len(self.trainer_event_dict)} total @ time={agg_time_since_start_s:.1f}s"
-        )
-        
-        return curr_unavail_trainer_list
-
     def check_and_sleep(self) -> None:
         """Induce transient unavailability"""
         pass
diff --git a/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md b/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md
index 887e2d15d..00312a1ca 100644
--- a/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md
+++ b/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md
@@ -114,7 +114,7 @@ each round). Two readings:
 | Streaming | **uniform (phase 1)** | one `full_after_s=10800`. Staggered (per-client onset≤5400 s, ±50% span) = phase 2 |
 | Time mode | **simulated** | virtual-clock time-to-accuracy, deterministic, fast |
 | Target accuracy | **60%** | |
-| Stop rule | **20 consecutive evals ≥ 60%** | resets on any dip; `rounds`/`max_runtime_s` safety cap |
+| Stop rule | **20 consecutive evals ≥ 60%** | resets on any dip; `rounds`/`max_experiment_runtime_s` safety cap |
 | Eval cadence | every **10** rounds | 20 evals ≈ 200 sustained rounds |
 
 **Arms (8).** `{felix, oort, refl, feddance} × {B, B_oracle}`. Each `B_oracle` uses
@@ -193,7 +193,7 @@ oracle runs are suffixed `_node<i>`).
   artifact of a single global unlock clock: staggering (clients' data arriving in
   different windows) should *amplify* the top-K churn and the baselines' disparity.
 - **"20 consecutive evals ≥ 60%"** yields a stable time-to-accuracy (not a lucky
-  spike); the `rounds`/`max_runtime_s` cap guarantees non-converging arms still
+  spike); the `rounds`/`max_experiment_runtime_s` cap guarantees non-converging arms still
   terminate.
 - **Simulated mode** gives a clean virtual-clock time axis, determinism, and speed.
 
diff --git a/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md b/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md
index 79521e459..26b4fde25 100644
--- a/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md
+++ b/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md
@@ -85,7 +85,7 @@ Follow‑ups at the bottom.
 **Config** (`config.py`, `Hyperparameters`): added
 `target_accuracy` (`targetAccuracy`, float, default `None` = disabled) and
 `stable_evals_above_target` (`stableEvalsAboveTarget`, int, default 20). The
-existing `rounds` and `max_runtime_s` remain the safety cap (the latter is already
+existing `rounds` and `max_experiment_runtime_s` remain the safety cap (the latter is already
 honored against the **virtual** clock in sim mode at `increment_round`).
 
 **Aggregator** (`syncfl/top_aggregator.py`, shared by sync + async stacks):
@@ -105,7 +105,7 @@ rounds rather than tens of thousands.
 
 **Acceptance**: smoke run with `targetAccuracy=0.2, stableEvalsAboveTarget=2`
 terminates shortly after two consecutive evals ≥ 0.2; a high target falls through
-to the `rounds`/`max_runtime_s` cap.
+to the `rounds`/`max_experiment_runtime_s` cap.
 
 ## B. Staggered per-client streaming
 
@@ -194,7 +194,7 @@ blocks on the aggregator config. Each arm: `num_trainers=50`,
 `data_streaming` (uniform `full_after_s=10800`; staggered adds the `stagger`
 block), `util_counterfactual` on, `checkpoint` on (offline oracle needs it),
 `aggGoal/aggr_num=10`, `targetAccuracy=0.60`, `stableEvalsAboveTarget=20`,
-`evalEveryNRounds=10`, `rounds=20000`/`max_runtime_s=12600` cap. felix `c=10`;
+`evalEveryNRounds=10`, `rounds=20000`/`max_experiment_runtime_s=12600` cap. felix `c=10`;
 `B_oracle` keeps B's own selector kwargs. Structure mirrors the working
 `felix_oort_refl_feddance_alpha0.1.yaml`.
 
diff --git a/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md b/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md
index adb688e24..a74711fcf 100644
--- a/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md
+++ b/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md
@@ -123,7 +123,7 @@ figures (see Verification below), `dg_flame` conda env.
 - **Config** — `lib/python/flame/config.py`: add hyperparameters
   `target_accuracy` (alias `targetAccuracy`, float, default `None` = disabled),
   `stable_evals_above_target` (alias, int, default 20). Reuse the existing `rounds` and
-  `max_runtime_s` as the safety cap (already honored in sim via the virtual clock).
+  `max_experiment_runtime_s` as the safety cap (already honored in sim via the virtual clock).
 - **Aggregator** — the eval result funnels through `_eval_emit(round, loss, acc)` in
   `lib/python/flame/mode/horizontal/syncfl/top_aggregator.py`
   (shared by sync + async stacks). Add a `_check_target_stop(acc)` called from `_eval_emit`:
@@ -193,7 +193,7 @@ figures (see Verification below), `dg_flame` conda env.
   `data_streaming.enabled: 'True'` (+ `stagger` block for the staggered variant),
   `util_counterfactual.enabled: 'True'`, `checkpoint.enabled: 'True'` + `every_n_rounds`
   (required for offline oracle), `aggGoal/aggr_num: 10`, `targetAccuracy: 0.60`,
-  `stableEvalsAboveTarget: 20`, `evalEveryNRounds: 10`, `rounds`/`max_runtime_s` cap. felix
+  `stableEvalsAboveTarget: 20`, `evalEveryNRounds: 10`, `rounds`/`max_experiment_runtime_s` cap. felix
   `selector.kwargs.c: 10`; oracle arm `c: 50`.
 
 ### E. Analysis + claim figures
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml
index e646fd11c..443ab1326 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             k: 8
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml
index 52ff2a455..a5f49cc5b 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             k: 8
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml
index 87087cf80..d48e87017 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml
@@ -43,7 +43,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             c: 8
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml
index d53d5d9de..89078f442 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml
@@ -43,7 +43,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             c: 8
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml
index e863ff5d2..2e57f4cc2 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             aggr_num: 5
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml
index adef5f2a8..684ac8d0a 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             aggr_num: 5
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml
index cc92117ea..128675a49 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml
@@ -39,7 +39,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         checkpoint:
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml
index 4737f99ef..8be0df0f5 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml
@@ -46,7 +46,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             c: 8
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml
index 201b35207..7cc3ae224 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml
@@ -46,7 +46,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             c: 8
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml
index f3ae65215..159521c83 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml
@@ -45,7 +45,7 @@ experiments:
           rounds: 40
           aggGoal: 8
           seed: 1234
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             c: 12
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml
index 653681627..9f07c7a72 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml
@@ -45,7 +45,7 @@ experiments:
           rounds: 40
           aggGoal: 8
           seed: 1234
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
         selector:
           kwargs:
             c: 12
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml
index 5b266aedc..6fd5f8076 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml
@@ -67,7 +67,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           evalEveryNRounds: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
@@ -111,7 +111,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           evalEveryNRounds: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
@@ -152,7 +152,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
           trackTrainerAvail: {trace: syn_0}
@@ -192,7 +192,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
           trackTrainerAvail: {trace: syn_0}
@@ -233,7 +233,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
           trackTrainerAvail: {trace: syn_0}
@@ -273,7 +273,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
           trackTrainerAvail: {trace: syn_0}
@@ -314,7 +314,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           evalEveryNRounds: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
@@ -354,7 +354,7 @@ experiments:
           batchSize: 10
           learningRate: 0.01
           rounds: 1000
-          max_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
+          max_experiment_runtime_s: 12600  # 3.5h wall-clock cap (data fully unlocks at 3h)
           aggGoal: 10
           evalEveryNRounds: 10
           checkpoint: {enabled: "True", every_n_rounds: 10}
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml
index 6b2b629ff..3d265b444 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml
@@ -38,7 +38,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         checkpoint:
@@ -101,7 +101,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         checkpoint:
           enabled: 'True'
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml
index 1125a87c0..af125748a 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         checkpoint:
           enabled: 'True'
@@ -105,7 +105,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         checkpoint:
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml
index 663adb0b2..db6f09f66 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml
@@ -38,7 +38,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
@@ -103,7 +103,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml
index 953dbd3ec..bc0825b98 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
@@ -110,7 +110,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml
index 29e11e960..dd8944410 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml
@@ -38,7 +38,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         checkpoint:
@@ -101,7 +101,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         checkpoint:
           enabled: 'True'
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml
index e1f914b75..0108a0e54 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         checkpoint:
           enabled: 'True'
@@ -105,7 +105,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         checkpoint:
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml
index e588ed18d..c21c64518 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml
@@ -41,7 +41,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
@@ -91,6 +91,18 @@ experiments:
         checkpoint:
           enabled: 'True'
           every_n_rounds: 50
+        # Stage C/D gate plumbing (§7): sim_unavailability activates the oracular
+        # delivery-ledger substrate for felix via the asyncfl commit loop. With
+        # syn_0 (100% avail) the mechanism fires but sees no UN_AVL → byte-identical
+        # behavior. client_notify.trace is overridden by debug_run.sh --trace;
+        # enabled stays False (Stage H).
+        # Two-axis flag split (T1): felix is the only baseline with both flags ON.
+        sim_unavailability: 'True'
+        avail_select_filter: 'True'
+        proactive_inflight_evict: 'True'
+        client_notify:
+          enabled: 'False'
+          trace: syn_0
       selector:
         kwargs:
           c: 30
@@ -156,7 +168,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 50
         checkpoint:
@@ -164,6 +176,12 @@ experiments:
           every_n_rounds: 50
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
+        sim_unavailability: 'True'
+        avail_select_filter: 'True'
+        proactive_inflight_evict: 'True'
+        client_notify:
+          enabled: 'False'
+          trace: syn_0
       selector:
         kwargs:
           c: 30
@@ -233,7 +251,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
@@ -242,6 +260,10 @@ experiments:
         # arrival, so sim in_flight (~3 carry) matches real. Sim-only; validated
         # by this run (Sr residence rung). See PARITY.md Jun-17c.
         simInflightCarryover: true
+        # oort is unaware at selection (avail_select_filter=False); the trace is
+        # used for starvation-advance vclock tracking only, not selection filtering.
+        avail_select_filter: 'False'
+        proactive_inflight_evict: 'False'
         checkpoint:
           enabled: 'True'
           every_n_rounds: 50
@@ -303,8 +325,12 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
+        # oort is unaware at selection (avail_select_filter=False); the trace is
+        # used for starvation-advance vclock tracking only, not selection filtering.
+        avail_select_filter: 'False'
+        proactive_inflight_evict: 'False'
         checkpoint:
           enabled: 'True'
           every_n_rounds: 50
@@ -368,7 +394,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
@@ -385,6 +411,9 @@ experiments:
         # in _advance_sim_clock (max(vclock,sct)+overhead, drift-instrumented), NOT a
         # clock ramp. Refine the value from the next run's K3b residual if over/under.
         simCommitOverheadSeconds: 0.011
+        # refl is aware at selection but not proactive-evict (reactive-90s).
+        avail_select_filter: 'True'
+        proactive_inflight_evict: 'False'
         checkpoint:
           enabled: 'True'
           every_n_rounds: 50
@@ -453,8 +482,11 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
+        # refl is aware at selection but not proactive-evict (reactive-90s).
+        avail_select_filter: 'True'
+        proactive_inflight_evict: 'False'
         checkpoint:
           enabled: 'True'
           every_n_rounds: 50
@@ -524,11 +556,14 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         min_trainers_to_start: 290
         min_trainers_join_timeout_s: 600
         aggGoal: 10
         evalEveryNRounds: 50
+        # feddance is aware at selection but not proactive-evict (reactive-90s).
+        avail_select_filter: 'True'
+        proactive_inflight_evict: 'False'
         checkpoint:
           enabled: 'True'
           every_n_rounds: 50
@@ -588,9 +623,12 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 50
+        # feddance is aware at selection but not proactive-evict (reactive-90s).
+        avail_select_filter: 'True'
+        proactive_inflight_evict: 'False'
         checkpoint:
           enabled: 'True'
           every_n_rounds: 50
@@ -610,3 +648,297 @@ experiments:
       ram_critical_percent: 90.0
       gpu_warning_percent: 80.0
       gpu_critical_percent: 90.0
+
+# ── oort_star ─────────────────────────────────────────────────────────────────
+# oort-sync base + avail_select_filter=True (T3 scaffold).
+# Aware at selection (filters UN_AVL), reactive-90s in-flight (no proactive evict).
+- name: oort_star_n300_alpha0.1_syn0_stream_sim
+  description: oort_star (oort sync + aware selection, no proactive evict) sim.
+  baseline: oort_star
+  trainer:
+    num_trainers: 300
+    start_id: 1
+    dataset:
+      name: cifar10
+      dirichlet_alpha: 0.1
+    availability:
+      mode: syn_0
+    enable_training_delays: true
+    time_mode: simulated
+    hyperparameters:
+      batchSize: 10
+      learningRate: 0.01
+      lrDecayEnabled: true
+      lrDecayFactor: 0.98
+      lrDecayEpoch: 10
+      minLearningRate: 0.0001
+    config_overrides:
+      hyperparameters:
+        data_streaming:
+          enabled: "True"
+          full_data_available_after_s: 10800
+        util_counterfactual:
+          enabled: "True"
+          every_n_rounds: 50
+          sample_size: 256
+  aggregator:
+    config_template: ../_metadata/aggregator_base.json
+    selector: oort
+    tracking_mode: oracular
+    agg_goal: 10
+    log_to_wandb: false
+    config_overrides:
+      job:
+        id: oort_star_n300_alpha0.1_syn0_stream_sim
+      hyperparameters:
+        batchSize: 10
+        learningRate: 0.01
+        rounds: 20000
+        max_experiment_runtime_s: 12600
+        min_trainers_to_start: 290
+        min_trainers_join_timeout_s: 600
+        aggGoal: 10
+        simInflightCarryover: true
+        avail_select_filter: "True"
+        proactive_inflight_evict: "False"
+        checkpoint:
+          enabled: "True"
+          every_n_rounds: 50
+        trackTrainerAvail:
+          trace: syn_0
+      selector:
+        kwargs:
+          aggr_num: 10
+  execution:
+    num_gpus: 8
+    sleep_between_spawns: 1.0
+    aggregator_warmup_time: 60
+    monitoring:
+      enabled: true
+      check_interval_seconds: 30
+      ram_warning_percent: 80.0
+      ram_critical_percent: 90.0
+      gpu_warning_percent: 80.0
+      gpu_critical_percent: 90.0
+- name: oort_star_n300_alpha0.1_syn0_stream_real
+  description: oort_star (oort sync + aware selection, no proactive evict) real.
+  baseline: oort_star
+  trainer:
+    num_trainers: 300
+    start_id: 1
+    dataset:
+      name: cifar10
+      dirichlet_alpha: 0.1
+    availability:
+      mode: syn_0
+    enable_training_delays: true
+    time_mode: real
+    hyperparameters:
+      batchSize: 10
+      learningRate: 0.01
+      lrDecayEnabled: true
+      lrDecayFactor: 0.98
+      lrDecayEpoch: 10
+      minLearningRate: 0.0001
+    config_overrides:
+      hyperparameters:
+        data_streaming:
+          enabled: "True"
+          full_data_available_after_s: 10800
+        util_counterfactual:
+          enabled: "True"
+          every_n_rounds: 50
+          sample_size: 256
+  aggregator:
+    config_template: ../_metadata/aggregator_base.json
+    selector: oort
+    tracking_mode: oracular
+    agg_goal: 10
+    log_to_wandb: false
+    config_overrides:
+      job:
+        id: oort_star_n300_alpha0.1_syn0_stream_real
+      hyperparameters:
+        batchSize: 10
+        learningRate: 0.01
+        rounds: 20000
+        max_experiment_runtime_s: 12600
+        aggGoal: 10
+        avail_select_filter: "True"
+        proactive_inflight_evict: "False"
+        checkpoint:
+          enabled: "True"
+          every_n_rounds: 50
+        trackTrainerAvail:
+          trace: syn_0
+        min_trainers_to_start: 290
+        min_trainers_join_timeout_s: 600
+      selector:
+        kwargs:
+          aggr_num: 10
+  execution:
+    num_gpus: 8
+    sleep_between_spawns: 1.0
+    aggregator_warmup_time: 60
+    monitoring:
+      enabled: true
+      check_interval_seconds: 30
+      ram_warning_percent: 80.0
+      ram_critical_percent: 90.0
+      gpu_warning_percent: 80.0
+      gpu_critical_percent: 90.0
+# ── fedbuff ───────────────────────────────────────────────────────────────────
+# asyncfl base + FedBuffSelector + both flags OFF (unaware, T3 scaffold).
+- name: fedbuff_n300_alpha0.1_syn0_stream_sim
+  description: fedbuff (asyncfl + fedbuff selector, both flags OFF) sim.
+  baseline: fedbuff
+  trainer:
+    num_trainers: 300
+    start_id: 1
+    dataset:
+      name: cifar10
+      dirichlet_alpha: 0.1
+    availability:
+      mode: syn_0
+    enable_training_delays: true
+    time_mode: simulated
+    hyperparameters:
+      # LR schedule matches felix and all other async cifar10 runs.
+      batchSize: 10
+      learningRate: 0.01
+      lrDecayEnabled: true
+      lrDecayFactor: 0.98
+      lrDecayEpoch: 10
+      minLearningRate: 0.0001
+    config_overrides:
+      hyperparameters:
+        data_streaming:
+          enabled: "True"
+          full_data_available_after_s: 10800
+        util_counterfactual:
+          enabled: "True"
+          every_n_rounds: 50
+          sample_size: 256
+  aggregator:
+    config_template: ../_metadata/aggregator_base.json
+    selector: fedbuff
+    tracking_mode: default
+    agg_goal: 10
+    log_to_wandb: false
+    config_overrides:
+      job:
+        id: fedbuff_n300_alpha0.1_syn0_stream_sim
+      hyperparameters:
+        batchSize: 10
+        learningRate: 0.01
+        rounds: 20000
+        max_experiment_runtime_s: 12600
+        min_trainers_to_start: 290
+        min_trainers_join_timeout_s: 600
+        aggGoal: 10
+        evalEveryNRounds: 50
+        simSctOrderedDrain: true
+        simClockJumpClamp: true
+        simInflightResidence: true
+        avail_select_filter: "False"
+        proactive_inflight_evict: "False"
+        sim_unavailability: "True"
+        availability_trace: syn_0
+        client_notify:
+          enabled: "False"
+          trace: syn_0
+        checkpoint:
+          enabled: "True"
+          every_n_rounds: 50
+      selector:
+        kwargs:
+          c: 30
+          aggGoal: 10
+          round_threshold: 70
+          exploration_decay: 0.999
+  execution:
+    num_gpus: 8
+    sleep_between_spawns: 1.0
+    aggregator_warmup_time: 60
+    monitoring:
+      enabled: true
+      check_interval_seconds: 30
+      ram_warning_percent: 80.0
+      ram_critical_percent: 90.0
+      gpu_warning_percent: 80.0
+      gpu_critical_percent: 90.0
+- name: fedbuff_n300_alpha0.1_syn0_stream_real
+  description: fedbuff (asyncfl + fedbuff selector, both flags OFF) real.
+  baseline: fedbuff
+  trainer:
+    num_trainers: 300
+    start_id: 1
+    dataset:
+      name: cifar10
+      dirichlet_alpha: 0.1
+    availability:
+      mode: syn_0
+    enable_training_delays: true
+    time_mode: real
+    hyperparameters:
+      # LR schedule matches felix and all other async cifar10 runs.
+      batchSize: 10
+      learningRate: 0.01
+      lrDecayEnabled: true
+      lrDecayFactor: 0.98
+      lrDecayEpoch: 10
+      minLearningRate: 0.0001
+    config_overrides:
+      hyperparameters:
+        data_streaming:
+          enabled: "True"
+          full_data_available_after_s: 10800
+        util_counterfactual:
+          enabled: "True"
+          every_n_rounds: 50
+          sample_size: 256
+  aggregator:
+    config_template: ../_metadata/aggregator_base.json
+    selector: fedbuff
+    tracking_mode: default
+    agg_goal: 10
+    log_to_wandb: false
+    config_overrides:
+      job:
+        id: fedbuff_n300_alpha0.1_syn0_stream_real
+      hyperparameters:
+        batchSize: 10
+        learningRate: 0.01
+        rounds: 20000
+        max_experiment_runtime_s: 12600
+        aggGoal: 10
+        evalEveryNRounds: 50
+        avail_select_filter: "False"
+        proactive_inflight_evict: "False"
+        sim_unavailability: "True"
+        availability_trace: syn_0
+        client_notify:
+          enabled: "False"
+          trace: syn_0
+        checkpoint:
+          enabled: "True"
+          every_n_rounds: 50
+        min_trainers_to_start: 290
+        min_trainers_join_timeout_s: 600
+      selector:
+        kwargs:
+          c: 30
+          aggGoal: 10
+          round_threshold: 70
+          exploration_decay: 0.999
+  execution:
+    num_gpus: 8
+    sleep_between_spawns: 1.0
+    aggregator_warmup_time: 60
+    monitoring:
+      enabled: true
+      check_interval_seconds: 30
+      ram_warning_percent: 80.0
+      ram_critical_percent: 90.0
+      gpu_warning_percent: 80.0
+      gpu_critical_percent: 90.0
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml
index 33b55173f..df2fdcbd7 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -106,7 +106,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml
index c8321ff9e..df3542118 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -105,7 +105,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml
index 601a483b5..81c108d0b 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -105,7 +105,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml
index 1210e376f..1a9e9ba92 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -105,7 +105,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml
index ede512daa..f4c23b9b3 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml
@@ -42,7 +42,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -106,7 +106,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -167,7 +167,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -220,7 +220,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -281,7 +281,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -334,7 +334,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -395,7 +395,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
@@ -448,7 +448,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 20000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         evalEveryNRounds: 10
         targetAccuracy: 0.6
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml
index e352df9d1..1bdc33f3e 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml
@@ -43,7 +43,7 @@ experiments:
         batchSize: 10
         learningRate: 0.01
         rounds: 1000
-        max_runtime_s: 12600
+        max_experiment_runtime_s: 12600
         aggGoal: 10
         checkpoint:
           enabled: 'True'
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml
index d1d066d86..1ac3fa384 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
           trackTrainerAvail:
             trace: syn_0
         selector:
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml
index f42ec358b..4b1881fa5 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
           trackTrainerAvail:
             trace: syn_0
         selector:
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml
index 20390d30e..497552c7c 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
           trackTrainerAvail:
             trace: syn_0
         selector:
diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml
index e26166e12..304e0e201 100644
--- a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml
+++ b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml
@@ -40,7 +40,7 @@ experiments:
           aggGoal: 5
           seed: 1234
           min_trainers_to_start: 48
-          max_runtime_s: 1200
+          max_experiment_runtime_s: 1200
           trackTrainerAvail:
             trace: syn_0
         selector:
diff --git a/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md b/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md
index 951528856..2290af0fa 100644
--- a/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md
+++ b/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md
@@ -7,7 +7,7 @@
 - real = `experiments/run_20260606_182638_dbg_felix_n300_alpha0.1_syn0_stream_real`
 
 Both: Felix (`async_oort` + `fedbuff`), n=300, α=0.1, syn_0, agg_goal=10,
-`max_runtime_s = sim_wall_ceiling_s = 10800s (3h)`, `min_trainers_to_start=290`.
+`max_experiment_runtime_s = sim_wall_ceiling_s = 10800s (3h)`, `min_trainers_to_start=290`.
 
 ---
 
@@ -107,7 +107,7 @@ Four findings:
    `rounds` cap, not the wall/vclock budget. **Fixed**: `rounds: 1000 → 20000` in
    `expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_OVERNIGHT_node{1,2}.yaml`
    (canonical source, covers overnight + debug) plus an explicit `h["rounds"]=20000`
-   guard in `scripts/debug_run.sh` (non-smoke branch, alongside the `max_runtime_s`
+   guard in `scripts/debug_run.sh` (non-smoke branch, alongside the `max_experiment_runtime_s`
    override). New checker check **K9** below makes truncation-by-cap an explicit WARN
    so it can never silently distort a comparison again.
 
@@ -277,7 +277,7 @@ gating; surface Jaccard as signal.
 | K6 | INV | sim mode: `task_recv.sim_send_ts` non-null & increasing after round 1; real mode: null | trainer task_recv | no violations |
 | K7 | INV | sim_rate (`vclock/wall`) in sane range [0.01, 100] | agg_round (sim) | in range |
 | K8 | DIST | **terminal-state parity**: at matched virtual budget V, both reached comparable FL-round count, total commits, total unique trainers used | agg_round | rounds within 10%, trainers within 5% |
-| K9 | INV | **stopped-by-budget, not by cap**: neither run hit the `rounds` cap before `max_runtime_s` — else the comparison is truncated and downstream metrics are biased | agg_round + config | WARN if `max_round == rounds_cap` and wall/vclock < budget |
+| K9 | INV | **stopped-by-budget, not by cap**: neither run hit the `rounds` cap before `max_experiment_runtime_s` — else the comparison is truncated and downstream metrics are biased | agg_round + config | WARN if `max_round == rounds_cap` and wall/vclock < budget |
 | K10 | INV | **vclock telemetry present**: a sim run's agg_round events must carry `vclock_now` (sync path currently omits it). FAIL-LOUD rather than silently SKIP K1–K3/K7 | agg_round (sim) | FAIL if sim run has zero `vclock_now` stamps |
 
 > **K2/K3/K4 are the checks that would have caught the 410-vs-673 regression on
diff --git a/lib/python/examples/async_cifar10/scripts/debug_run.sh b/lib/python/examples/async_cifar10/scripts/debug_run.sh
index 492e134dd..fe24b6326 100755
--- a/lib/python/examples/async_cifar10/scripts/debug_run.sh
+++ b/lib/python/examples/async_cifar10/scripts/debug_run.sh
@@ -17,7 +17,7 @@
 # baseline is a no-op (not an error).
 #
 # Runtime:
-#   --runtime-s sets max_runtime_s for BOTH real and sim variants.
+#   --runtime-s sets max_experiment_runtime_s for BOTH real and sim variants.
 #   Real mode:  wall-clock seconds (passes directly).
 #   Sim mode:   virtual-clock seconds (vclock fix ensures sim stops at this
 #               many virtual seconds, which completes in far less wall-clock
@@ -49,20 +49,22 @@ echo "conda: base=$CB env=$ENVNAME python=$(which python)"
 EX="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$EX" || exit 1
 SCR=expt_scripts_2026
-LOGDIR=/tmp/debug_run_logs; mkdir -p "$LOGDIR"
+LOGDIR="${FLAME_LOGDIR:-/tmp/debug_run_logs}"; mkdir -p "$LOGDIR"
 export FLAME_BATCH_CONTINUE_ON_ERROR=1
 
 # defaults
 RUNTIME_S=10800
 BASELINES="felix refl"
-SIM_WALL_CEILING_S=""  # empty = max_runtime_s (1×, tight guard; sim should be faster than real)
+SIM_WALL_CEILING_S=""  # empty = max_experiment_runtime_s (1×, tight guard; sim should be faster than real)
 MODE="both"            # sim | real | both — which time_mode variant(s) of each baseline to run
+NUM_TRAINERS=""        # empty = use whatever's in the parity config (300); non-smoke override only
+ALPHA=""               # empty = use the parity config's dirichlet_alpha (0.1); e.g. 100 for homogeneous
 
 usage() {
-  echo "usage: $0 [--baselines 'felix refl'] [--runtime-s 3600] [--mode sim|real|both] [--sim-wall-ceiling-s 2700]"
-  echo "       $0 smoke [--baselines ...] [--mode sim|real|both]"
+  echo "usage: $0 [--baselines 'felix refl'] [--runtime-s 3600] [--mode sim|real|both] [--sim-wall-ceiling-s 2700] [--trace syn_20]"
+  echo "       $0 smoke [--baselines ...] [--mode sim|real|both] [--trace syn_20]"
   echo ""
-  echo "  --baselines           which baselines to run (any of felix oort refl feddance);"
+  echo "  --baselines           which baselines to run (any of felix oort oort_star refl feddance fedbuff);"
   echo "                        filtered from the parity config, node-agnostic."
   echo "  --mode                which time_mode variant(s) to run for each baseline:"
   echo "                        'sim' (only the simulated run), 'real' (only the real run),"
@@ -71,17 +73,31 @@ usage() {
   echo "  --sim-wall-ceiling-s  wall-clock ceiling for sim mode (default: = runtime_s)."
   echo "                        A well-behaved sim finishes in <= real-mode wall time."
   echo "                        Fires [SIM_WALL_CEILING] warning + stops when exceeded."
+  echo "  --trace               availability trace name(s) to substitute, space-separated for"
+  echo "                        multiple (e.g. 'syn_20 syn_50' queues both, one experiment set each)."
+  echo "                        Default: use whatever is in the parity config (syn_0)."
+  echo "  --num-trainers        non-smoke only: shrink the cohort below the parity config's 300,"
+  echo "                        scaling min_trainers_to_start down with it (gap of 8, same ratio as"
+  echo "                        smoke). Use this instead of 'smoke' when you need a real --runtime-s"
+  echo "                        budget (e.g. a vclock floor for an availability trace) that smoke's"
+  echo "                        hardcoded rounds=4/runtime=240 would cut short."
+  echo "  --alpha               Dirichlet alpha override (default: parity config's 0.1). Supported"
+  echo "                        values have an n300 split: 0.1 / 1.0 / 10.0 / 100.0 (100=homogeneous)."
+  echo "                        When set, the split lookup uses the n300 partition for that alpha."
   exit 2
 }
 
 # parse args
+TRACE=""  # empty = use whatever is in the parity config (syn_0)
 if [ "${1:-}" = "smoke" ]; then
   SMOKE=1; shift
-  BASELINES="felix oort refl feddance"   # smoke default: validate all
+  BASELINES="felix oort oort_star refl feddance fedbuff"   # smoke default: validate all
   while [[ $# -gt 0 ]]; do
     case "$1" in
       --baselines) BASELINES="$2"; shift 2 ;;
       --mode)      MODE="$2"; shift 2 ;;
+      --trace)     TRACE="$2"; shift 2 ;;
+      --alpha)     ALPHA="$2"; shift 2 ;;
       *) shift ;;
     esac
   done
@@ -94,6 +110,9 @@ else
       --mode)                MODE="$2"; shift 2 ;;
       --sim-wall-ceiling-s)  SIM_WALL_CEILING_S="$2"; shift 2 ;;
       --wall-runtime-s)      SIM_WALL_CEILING_S="$2"; shift 2 ;;  # backward compat alias
+      --trace)               TRACE="$2"; shift 2 ;;
+      --num-trainers)        NUM_TRAINERS="$2"; shift 2 ;;
+      --alpha)               ALPHA="$2"; shift 2 ;;
       # --node is DEPRECATED (node1/node2 split removed): baselines are filtered
       # from a single node-agnostic parity config, so the node is irrelevant.
       # Accept+ignore so existing wrappers don't hard-error.
@@ -106,15 +125,21 @@ case "$MODE" in sim|real|both) ;; *) echo "ERROR: --mode must be sim|real|both (
 
 # Generate a single filtered+patched YAML from the parity source config.
 # $1 = baselines (space-separated), $2 = runtime_s, $3 = output path,
-# [$4 = smoke: 1|0], [$5 = sim_wall_ceiling_s: int or ""], [$6 = mode: sim|real|both]
+# [$4 = smoke: 1|0], [$5 = sim_wall_ceiling_s: int or ""], [$6 = mode: sim|real|both],
+# [$7 = trace: trace name or ""], [$8 = num_trainers override: int or "", non-smoke only],
+# [$9 = alpha override: float or ""]
 make_debug_yaml() {
-  python - "$SCR" "$1" "$2" "$3" "${4:-0}" "${5:-}" "${6:-both}" <<'PY'
+  python - "$SCR" "$1" "$2" "$3" "${4:-0}" "${5:-}" "${6:-both}" "${7:-}" "${8:-}" "${9:-}" <<'PY'
 import yaml, sys, copy, os
 scr, baselines_str, runtime_s, outpath, smoke, ceil_arg = (
     sys.argv[1], sys.argv[2], int(sys.argv[3]), sys.argv[4], sys.argv[5] == "1",
     sys.argv[6] if len(sys.argv) > 6 else ""
 )
 mode = (sys.argv[7] if len(sys.argv) > 7 else "both").lower()
+# Space-separated list of trace names (e.g. "syn_20 syn_50"); "" -> [""] (no substitution).
+trace_overrides = sys.argv[8].strip().split() if len(sys.argv) > 8 and sys.argv[8].strip() else [""]
+num_trainers_override = int(sys.argv[9]) if len(sys.argv) > 9 and sys.argv[9].strip() else None
+alpha_override = float(sys.argv[10]) if len(sys.argv) > 10 and sys.argv[10].strip() else None
 requested = set(baselines_str.lower().split())
 # Deterministic selection seed (same for real+sim). Default 1234; SEED=none disables.
 _seed_env = os.environ.get("SEED", "1234").strip()
@@ -141,44 +166,127 @@ def exp_mode(e):
 # feddance) × {sim, real}; filter it to the requested baselines/mode.
 src = f"{scr}/felix_oort_refl_feddance_alpha0.1_parity.yaml"
 try:
-    cfg = yaml.safe_load(open(src))
+    # encoding="utf-8" explicit: the config has non-ASCII chars (e.g. "->" arrows
+    # in comments/descriptions); without this, open() falls back to the node's
+    # locale-preferred encoding, which mis-decodes them on non-UTF-8 locales
+    # (e.g. C/POSIX) and yaml.safe_load then rejects the resulting control chars.
+    cfg = yaml.safe_load(open(src, encoding="utf-8"))
 except FileNotFoundError:
     print(f"ERROR: parity config not found: {src}", flush=True)
     sys.exit(1)
 
 kept = []
-for e in cfg.get("experiments", []):
-    bl = e.get("baseline", "").lower()
+for e_src in cfg.get("experiments", []):
+    bl = e_src.get("baseline", "").lower()
     if bl not in requested:
         continue
-    if mode != "both" and exp_mode(e) != mode:
+    if mode != "both" and exp_mode(e_src) != mode:
         continue
-    e = copy.deepcopy(e)
-    h = e["aggregator"]["config_overrides"]["hyperparameters"]
-    h["max_runtime_s"] = runtime_s
-    # Deterministic seed: the SAME value for every experiment so the real and sim
-    # variants of each baseline make identical selection draws (dedicated per-
-    # selector RNG, PARITY "Determinism / seeding"). Without this, real vs sim are
-    # two independent stochastic paths and participation/utility can never match.
-    # Override per-invocation with SEED=<n>; SEED=none disables (legacy unseeded).
-    if seed_val is not None:
-        h["seed"] = seed_val
-    # sim_wall_ceiling_s: tight wall guard — sim must finish in <= this many
-    # wall-seconds (default = max_runtime_s = 1×; a healthy sim is faster).
-    h["sim_wall_ceiling_s"] = int(ceil_arg) if ceil_arg else runtime_s
-    if smoke:
-        e["trainer"]["num_trainers"] = 48
-        h["rounds"] = 4
-        h["min_trainers_to_start"] = 40
-        h["min_trainers_join_timeout_s"] = 120
-        e["name"] = "dbg_smoke_" + e["name"]
-    else:
-        # High round cap so the wall/vclock budget (max_runtime_s) is the
-        # binding stop condition, not an early round-count termination.
-        h["rounds"] = 20000
-        e["name"] = f"dbg_{e['name']}"
-    e["aggregator"]["config_overrides"]["job"]["id"] = e["name"]
-    kept.append(e)
+    # One experiment per requested trace (trace_overrides has 1 entry, "", when
+    # --trace wasn't given, so this loop is a no-op pass-through by default).
+    for trace_override in trace_overrides:
+        e = copy.deepcopy(e_src)
+        h = e["aggregator"]["config_overrides"]["hyperparameters"]
+        h["max_experiment_runtime_s"] = runtime_s
+        # Deterministic seed: the SAME value for every experiment so the real and sim
+        # variants of each baseline make identical selection draws (dedicated per-
+        # selector RNG, PARITY "Determinism / seeding"). Without this, real vs sim are
+        # two independent stochastic paths and participation/utility can never match.
+        # Override per-invocation with SEED=<n>; SEED=none disables (legacy unseeded).
+        if seed_val is not None:
+            h["seed"] = seed_val
+        # sim_wall_ceiling_s: tight wall guard -- sim must finish in <= this many
+        # wall-seconds (default = max_experiment_runtime_s = 1x; a healthy sim is faster).
+        h["sim_wall_ceiling_s"] = int(ceil_arg) if ceil_arg else runtime_s
+        if smoke:
+            e["trainer"]["num_trainers"] = 48
+            h["rounds"] = 4
+            h["min_trainers_to_start"] = 40
+            h["min_trainers_join_timeout_s"] = 120
+            e["name"] = "dbg_smoke_" + e["name"]
+        else:
+            # High round cap so the wall/vclock budget (max_experiment_runtime_s) is the
+            # binding stop condition, not an early round-count termination.
+            h["rounds"] = 20000
+            if num_trainers_override:
+                # Shrink the cohort but keep runtime_s as the real budget (unlike
+                # smoke, which hardcodes rounds=4/runtime=240 -- too short for a
+                # trace-driven vclock floor like syn_20's first UN_AVL at t=600s).
+                # Same join-barrier slack ratio as smoke (gap of 8 below the count).
+                # Preserve the config's native partition size as split_num_trainers
+                # so the shrunk cohort reads the existing n<orig> split (e.g. n300)
+                # instead of demanding a dedicated n<override> split file that may
+                # not exist (there is no cifar10_alpha0.1_n10 split, only n48/50/300).
+                # spawn_all spawns num_trainers trainers but keys the split lookup on
+                # split_num_trainers -- the two are independent by design.
+                orig_n = e["trainer"].get("num_trainers", 300)
+                e["trainer"]["num_trainers"] = num_trainers_override
+                e["trainer"]["split_num_trainers"] = orig_n
+                h["min_trainers_to_start"] = max(1, num_trainers_override - 8)
+            e["name"] = f"dbg_{e['name']}"
+        # --alpha override: repoint dirichlet_alpha and the split lookup. Only n300
+        # splits exist for every alpha (0.1/1.0/10.0/100.0=homogeneous); n48/n50
+        # exist for alpha0.1 only. So read the n300 partition for the chosen alpha
+        # (the cohort stays num_trainers, spawned as the first num_trainers of the
+        # 300-way split via the split_num_trainers decoupling). Name gets an
+        # alpha<..> tag so run dirs are distinguishable across alphas.
+        if alpha_override is not None:
+            e["trainer"].setdefault("dataset", {})["dirichlet_alpha"] = alpha_override
+            e["trainer"]["split_num_trainers"] = 300
+            e["name"] = f"{e['name']}_alpha{str(alpha_override).replace('.', 'p')}"
+        # --trace override: substitute availability trace in trainer + aggregator config.
+        if trace_override:
+            # trainer.availability.mode is NOT read by anything (main.py/config.py never
+            # touch config.availability) -- vestigial from an earlier design, kept
+            # write-only here so as not to silently drop a field some other consumer may
+            # still expect. The trainer's ACTUAL trace selection comes from
+            # hyperparameters.client_notify.trace (see main.py's state_avl_event_ts
+            # assignment), which lives under trainer.config_overrides.hyperparameters,
+            # not trainer.hyperparameters (that block is base-model HP only: batchSize/
+            # learningRate/etc, merged from configs/trainer_base.yaml's own client_notify
+            # default of trace=syn_0). Before this fix, ONLY the aggregator's own trace
+            # read (via `h` below) was ever overridden -- every debug_run.sh-launched
+            # trainer, real and sim, ran with client_notify.trace stuck at the
+            # trainer_base.yaml default (syn_0, always-available) regardless of the
+            # requested --trace, silently no-op'ing the trainer-side avl_state machinery
+            # (and hence the real-mode send-gate and all avail_change telemetry) for
+            # every trace-driven run this project has ever launched. Root-caused Jul 1
+            # via UNAVAILABILITY_DESIGN.md Batch 3 T3.1.
+            avail = e["trainer"].setdefault("availability", {})
+            old_trace = avail.get("mode", "syn_0")
+            avail["mode"] = trace_override
+            t_co_hp = e["trainer"].setdefault("config_overrides", {}).setdefault("hyperparameters", {})
+            t_co_hp.setdefault("client_notify", {})["trace"] = trace_override
+            if "trackTrainerAvail" in h:
+                h["trackTrainerAvail"]["trace"] = trace_override
+                # For baselines NOT on the ORACULAR legacy path (felix, feddance,
+                # oracle, fedbuff): activate the new sim_unavailability gate so
+                # _init_availability picks up the trace (Sec 7 felix master-gate).
+                # ORACULAR baselines (oort, refl) already activate via the legacy path.
+                if h["trackTrainerAvail"].get("type", "").upper() != "ORACULAR":
+                    h["simUnavailability"] = True
+                    # proactive_inflight_evict is set directly in each experiment's
+                    # config_overrides HP (T1 two-axis split); no auto-detection needed
+                    # here. The client_notify.enabled check below is always False
+                    # (Stage H is future), so proactiveInflightEvict is never set by
+                    # this branch -- the explicit YAML value is authoritative.
+                    t_hp = e.get("trainer", {}).get("hyperparameters", {})
+                    if str(t_hp.get("client_notify", {}).get("enabled", "False")).lower() == "true":
+                        h["proactiveInflightEvict"] = True
+            elif "client_notify" in h and isinstance(h["client_notify"], dict):
+                h["client_notify"]["trace"] = trace_override
+                h["simUnavailability"] = True
+            elif e["aggregator"].get("tracking_mode", "oracular").lower() != "oracular":
+                # Non-oracular baseline with no HP-level tracking block (e.g. feddance
+                # in v1, which has no client_notify in HP and no trackTrainerAvail).
+                # Inject trace via availability_trace so _init_availability finds it.
+                h["availability_trace"] = trace_override
+                h["simUnavailability"] = True
+            # Rewrite syn_<digits> or syn<digits> in the name so run dirs are identifiable.
+            import re
+            e["name"] = re.sub(r"syn_?[0-9]+", trace_override, e["name"])
+        e["aggregator"]["config_overrides"]["job"]["id"] = e["name"]
+        kept.append(e)
 
 if not kept:
     print(f"WARNING: no experiments matched baselines={baselines_str} mode={mode}",
@@ -186,19 +294,61 @@ if not kept:
     sys.exit(0)
 
 cfg["experiments"] = kept
-yaml.safe_dump(cfg, open(outpath, "w"), sort_keys=False)
+yaml.safe_dump(cfg, open(outpath, "w", encoding="utf-8"), sort_keys=False)
 print(f"Generated {outpath} with {len(kept)} experiment(s): "
       f"{[e['name'] for e in kept]}", flush=True)
 PY
 }
 
+# Count experiments in a generated YAML (used to estimate budget and track progress).
+_count_exps() {
+  python3 - "$1" <<'PY'
+import yaml, sys
+d = yaml.safe_load(open(sys.argv[1], encoding="utf-8"))
+print(len(d.get('experiments', [])))
+PY
+}
+
 run_node() {
-  local label="$1" cfg="$2"
-  echo "[$(date '+%F %T')] START $label -> $cfg" | tee -a "$LOGDIR/debug_run.log"
+  local label="$1" cfg="$2" budget_s="${3:-0}" n_exps="${4:-1}"
+  local start_ts; start_ts=$(date +%s)
+  # Baseline run-dir count — new dirs that appear are newly-started experiments.
+  local initial_runs; initial_runs=$(find experiments -maxdepth 1 -name "run_*" -type d 2>/dev/null | wc -l)
+
+  echo "[$(date '+%F %T')] START $label ($n_exps exp(s), ~${budget_s}s budget)" | tee -a "$LOGDIR/debug_run.log"
+
+  # Background progress ticker: fires every 30s, prints elapsed/remaining/percent
+  # and how many experiments have started (each start creates a new run_* dir).
+  (
+    while true; do
+      sleep 30
+      local now; now=$(date +%s)
+      local elapsed=$(( now - start_ts ))
+      local pct=0 remaining=0
+      if [ "$budget_s" -gt 0 ]; then
+        pct=$(( elapsed * 100 / budget_s ))
+        remaining=$(( budget_s - elapsed ))
+        [ "$pct" -gt 100 ] && pct=100
+        [ "$remaining" -lt 0 ] && remaining=0
+      fi
+      local curr; curr=$(find experiments -maxdepth 1 -name "run_*" -type d 2>/dev/null | wc -l)
+      local started=$(( curr - initial_runs ))
+      [ "$started" -lt 0 ] && started=0
+      printf "  [%s] %s | %ds elapsed / ~%ds (%d%%) | exp started: %d/%d\n" \
+        "$(date '+%T')" "$label" "$elapsed" "$budget_s" "$pct" "$started" "$n_exps"
+    done
+  ) &
+  local ticker_pid=$!
+
   python -m flame.launch.run_experiment "$cfg" --example-dir "$EX" \
       < /dev/null >> "$LOGDIR/${label}.out" 2>&1
   local rc=$?
-  echo "[$(date '+%F %T')] DONE  $label exit=$rc" | tee -a "$LOGDIR/debug_run.log"
+
+  kill "$ticker_pid" 2>/dev/null
+  wait "$ticker_pid" 2>/dev/null
+
+  local elapsed=$(( $(date +%s) - start_ts ))
+  echo "[$(date '+%F %T')] DONE  $label exit=$rc (took ${elapsed}s / ~${budget_s}s budget)" | tee -a "$LOGDIR/debug_run.log"
 }
 
 # ---- smoke mode ----
@@ -208,8 +358,11 @@ if [ "$SMOKE" = "1" ]; then
   # Clear any stale config from a previous invocation so a no-match run is
   # skipped (not silently re-running a leftover config).
   rm -f "$cfg"
-  make_debug_yaml "$BASELINES" 240 "$cfg" 1 "$SIM_WALL_CEILING_S" "$MODE"
-  [ -f "$cfg" ] && run_node "dbg_smoke" "$cfg"
+  make_debug_yaml "$BASELINES" 240 "$cfg" 1 "$SIM_WALL_CEILING_S" "$MODE" "$TRACE" "" "$ALPHA"
+  if [ -f "$cfg" ]; then
+    _n=$(_count_exps "$cfg")
+    run_node "dbg_smoke" "$cfg" $(( _n * 240 )) "$_n"
+  fi
   echo "=== SMOKE RESULTS ==="
   for dd in experiments/run_*dbg_smoke_*; do
     [ -d "$dd" ] || continue
@@ -221,18 +374,21 @@ if [ "$SMOKE" = "1" ]; then
 fi
 
 # ---- normal run mode ----
-echo "=== DEBUG RUN: baselines='$BASELINES' mode=$MODE runtime_s=$RUNTIME_S sim_wall_ceiling_s=${SIM_WALL_CEILING_S:-auto(=runtime_s)} ==="
+echo "=== DEBUG RUN: baselines='$BASELINES' mode=$MODE runtime_s=$RUNTIME_S sim_wall_ceiling_s=${SIM_WALL_CEILING_S:-auto(=runtime_s)} num_trainers=${NUM_TRAINERS:-300(default)} alpha=${ALPHA:-0.1(default)} ==="
 cfg="$LOGDIR/debug_run.yaml"
 # Clear any stale config so a no-match run is skipped (not silently re-running
 # a previous baseline's leftover config).
 rm -f "$cfg"
-make_debug_yaml "$BASELINES" "$RUNTIME_S" "$cfg" 0 "$SIM_WALL_CEILING_S" "$MODE"
+make_debug_yaml "$BASELINES" "$RUNTIME_S" "$cfg" 0 "$SIM_WALL_CEILING_S" "$MODE" "$TRACE" "$NUM_TRAINERS" "$ALPHA"
 
 if [ ! -f "$cfg" ]; then
   echo "No experiments matched for baselines='$BASELINES'. Nothing to run."
   exit 0
 fi
 
-run_node "debug_run" "$cfg"
+_n_exps=$(_count_exps "$cfg")
+_budget=$(( _n_exps * RUNTIME_S ))
+echo "  queued: $_n_exps exp(s), estimated budget ~${_budget}s (sim finishes faster than real)"
+run_node "debug_run" "$cfg" "$_budget" "$_n_exps"
 echo "Logs: $LOGDIR/debug_run.out"
 echo "Run dirs: experiments/run_*dbg_*"
diff --git a/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py b/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py
index 602a4a161..1e3a16b0c 100755
--- a/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py
+++ b/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py
@@ -83,7 +83,7 @@ def make_arm(baseline, staggered, oracle=False, suffix=""):
     name = f"{baseline}{ocl}_n50_alpha0.1_syn0_stream_{cond}_sim{suffix}"
     agg_hp = {
         "batchSize": 10, "learningRate": 0.01,
-        "rounds": ROUNDS_CAP, "max_runtime_s": MAX_RUNTIME_S,
+        "rounds": ROUNDS_CAP, "max_experiment_runtime_s": MAX_RUNTIME_S,
         "aggGoal": 10, "evalEveryNRounds": EVAL_EVERY,
         "targetAccuracy": TARGET_ACC, "stableEvalsAboveTarget": STABLE_EVALS,
         "min_trainers_to_start": N - 2, "min_trainers_join_timeout_s": 600,
diff --git a/lib/python/examples/async_cifar10/scripts/parity/avail_state_series.py b/lib/python/examples/async_cifar10/scripts/parity/avail_state_series.py
new file mode 100644
index 000000000..00344ce07
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/parity/avail_state_series.py
@@ -0,0 +1,183 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Shared per-trainer availability-state series builder (Stage C.6.2).
+
+Single resolver, imported by both checks.py (Aa / A4dur / observation_lag rungs)
+and analyze_run.py (the four plots re-pointed in C.6.4), so the forward-fill
+semantics never diverge between the checker and the plotter (Challenge 12
+discipline — one function, not a duplicated copy in each consumer).
+
+Reads `per_trainer[end_id]["avl_state"]` on each `selection` event (C.6.1).
+Time-base: both modes prefer `vclock_now`, stamped on the event via
+`ClientAvailability._avail_now()` (sim: `_vclock.now`; real: wall-elapsed since
+`agg_start_time_ts`) — the same shared origin the rest of the availability
+substrate uses. Telemetry recorded before real-mode `vclock_now` stamping was
+added falls back to `ts - t0` (t0 = the run's first selection event ts), which
+is a *biased* estimate: real's first selection event fires only once enough
+trainers have joined over MQTT (~300s for n=300), so it under-counts elapsed
+time relative to the trace's true origin and skews any duration-weighted
+comparison (A4dur) for trainers whose state changes mid-run. Kept only for
+backward-compat with old runs — new telemetry should always carry vclock_now.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+def _event_time(e: dict, mode: str, t0: float) -> Optional[float]:
+    vclock = e.get("vclock_now")
+    if vclock is not None:
+        return vclock
+    if mode == "sim":
+        return None
+    ts = e.get("ts")
+    return None if ts is None else ts - t0
+
+
+def build_trainer_state_series(
+    selection_events: list, mode: str
+) -> dict[str, list]:
+    """{end_id: [(t, avl_state), ...]} forward-fill series, sorted by t.
+
+    mode: "sim" or "real", both preferring t = vclock_now, falling back to
+    ts - t0 only for real-mode telemetry recorded before vclock_now was
+    stamped on real selection events. One sample per
+    end_id per selection event it appears as a candidate in (whether or not
+    selected) — `avail_composition`/`per_trainer` already cover every
+    candidate in the pool, not just the chosen subset. Consecutive samples at
+    the same t collapse to the last write (same-instant events, e.g. carried
+    pacer state).
+    """
+    real_ts = [e.get("ts") for e in selection_events if e.get("ts") is not None]
+    t0 = min(real_ts) if (mode == "real" and real_ts) else 0.0
+
+    series: dict[str, list] = {}
+    for e in sorted(
+        selection_events, key=lambda x: (x.get("round", 0), x.get("ts", 0.0))
+    ):
+        t = _event_time(e, mode, t0)
+        if t is None:
+            continue
+        for end_id, cand in (e.get("per_trainer") or {}).items():
+            state = cand.get("avl_state")
+            if state is None or state == "UNKNOWN":
+                continue
+            pts = series.setdefault(end_id, [])
+            if pts and pts[-1][0] == t:
+                pts[-1] = (t, state)
+            else:
+                pts.append((t, state))
+    return series
+
+
+def build_observed_timeline_from_avail_change(avail_change_events: list) -> list:
+    """Sorted [(sim_now, new_state), ...] from one trainer's own avail_change telemetry.
+
+    ``sim_now`` (Batch 3 T3.2) is the trainer's own trace-time-basis clock at
+    the moment it applied the transition — sim: virtual-clock seconds; real:
+    wall-elapsed since the shared AGG_START_TS origin (T3.0). Distinct from
+    the record's ``ts`` (always wall time.time(), meaningless against a trace
+    indexed in trace-seconds). Events recorded before ``sim_now`` existed are
+    dropped; an entirely-empty result means "no fidelity signal for this
+    trainer" (old telemetry), not "trainer never transitioned" — the A6
+    caller must treat empty-with-no-events differently only if it also has no
+    sim_now-tagged events at all across the whole run (checked once, not per
+    trainer).
+    """
+    pts: list = []
+    for e in sorted(
+        avail_change_events, key=lambda x: (x.get("round", 0), x.get("ts", 0.0))
+    ):
+        t = e.get("sim_now")
+        state = e.get("new_state")
+        if t is None or state is None:
+            continue
+        if pts and pts[-1][0] == t:
+            pts[-1] = (t, state)
+        else:
+            pts.append((t, state))
+    return pts
+
+
+def build_observed_timeline_from_agg_belief(events: list) -> list:
+    """Sorted [(observed_at, state), ...] from one trainer's own
+    agg_belief_change telemetry (Batch 3 T3.3), already filtered by the
+    caller to a single end_id and checkpoint ("selection" | "commit").
+
+    ``observed_at`` is the trace-time-basis clock the belief was read at
+    (vclock seconds / wall-elapsed since the shared origin) -- same role as
+    avail_change's ``sim_now`` in build_observed_timeline_from_avail_change,
+    just a different telemetry stream (aggregator belief vs. trainer's own
+    self-report).
+    """
+    pts: list = []
+    for e in sorted(
+        events, key=lambda x: (x.get("round", 0), x.get("observed_at", 0.0))
+    ):
+        t = e.get("observed_at")
+        state = e.get("state")
+        if t is None or state is None:
+            continue
+        if pts and pts[-1][0] == t:
+            pts[-1] = (t, state)
+        else:
+            pts.append((t, state))
+    return pts
+
+
+def selection_run_span(selection_events: list, mode: str) -> float:
+    """Max observed time across all selection events.
+
+    Unlike run_span() (which needs a built per-trainer avl_state series),
+    this only needs the events' own ts/vclock_now -- usable by checks that
+    just need the run's overall time horizon and nothing about per-trainer
+    avail state (e.g. A6, which reads its own per-trainer state from
+    avail_change telemetry instead). Same t = vclock_now / (ts - t0)
+    time-base convention as build_trainer_state_series.
+    """
+    real_ts = [e.get("ts") for e in selection_events if e.get("ts") is not None]
+    t0 = min(real_ts) if (mode == "real" and real_ts) else 0.0
+    times = [
+        t for t in (_event_time(e, mode, t0) for e in selection_events)
+        if t is not None
+    ]
+    return max(times) if times else 0.0
+
+
+def run_span(series: dict) -> float:
+    """Max observed t across all trainers — the run's own time horizon."""
+    return max((pts[-1][0] for pts in series.values() if pts), default=0.0)
+
+
+def state_fractions(series: dict, t_end: Optional[float] = None) -> dict:
+    """Per-trainer {state: fraction_of_span} from a forward-filled series.
+
+    Dwell-time integration: each sample's state holds until the next sample
+    (or `t_end` for the trailing segment, default = the trainer's own last
+    sample — i.e. no tail credited beyond its last observation). Trainers
+    with < 2 samples are omitted (no observed dwell to integrate). Per-trainer
+    vectors sum to 1.
+    """
+    out: dict = {}
+    for end_id, pts in series.items():
+        if len(pts) < 2:
+            continue
+        durations: dict = {}
+        for (t_a, s_a), (t_b, _) in zip(pts, pts[1:]):
+            durations[s_a] = durations.get(s_a, 0.0) + max(0.0, t_b - t_a)
+        last_t, last_s = pts[-1]
+        end_t = t_end if t_end is not None else last_t
+        if end_t > last_t:
+            durations[last_s] = durations.get(last_s, 0.0) + (end_t - last_t)
+        total = sum(durations.values())
+        if total <= 0:
+            continue
+        out[end_id] = {s: d / total for s, d in durations.items()}
+    return out
+
+
+def total_variation_distance(a: dict, b: dict) -> float:
+    """0.5 * Σ_s |a_s - b_s| over the union of states; 0 if identical."""
+    keys = set(a) | set(b)
+    return 0.5 * sum(abs(a.get(k, 0.0) - b.get(k, 0.0)) for k in keys)
diff --git a/lib/python/examples/async_cifar10/scripts/parity/checks.py b/lib/python/examples/async_cifar10/scripts/parity/checks.py
index effc43fc7..984939709 100644
--- a/lib/python/examples/async_cifar10/scripts/parity/checks.py
+++ b/lib/python/examples/async_cifar10/scripts/parity/checks.py
@@ -26,6 +26,22 @@
 import re
 import statistics
 from pathlib import Path
+
+from .avail_state_series import (
+    build_observed_timeline_from_agg_belief,
+    build_observed_timeline_from_avail_change,
+    build_trainer_state_series,
+    run_span,
+    selection_run_span,
+    state_fractions,
+    total_variation_distance,
+)
+from .ground_truth import (
+    by_short_id,
+    expected_send_gate_wait,
+    state_fractions_over_range,
+    transitions_in_range,
+)
 from typing import Optional
 
 
@@ -190,6 +206,9 @@ def load_agg_jsonl(path: str) -> dict:
     eval_commits: list = []
     agg_evals: list = []
     residence: list = []
+    withheld_deliveries: list = []
+    abandon_timeouts: list = []
+    agg_belief_changes: list = []
     with open(path) as f:
         for line in f:
             line = line.strip()
@@ -199,6 +218,12 @@ def load_agg_jsonl(path: str) -> dict:
             ev = e.get("event")
             if ev == "selection" and e.get("task") == "train":
                 selection_train.append(e)
+            elif ev == "withheld_delivery":
+                withheld_deliveries.append(e)
+            elif ev == "abandon_timeout":
+                abandon_timeouts.append(e)
+            elif ev == "agg_belief_change":
+                agg_belief_changes.append(e)
             elif ev == "agg_round":
                 # Eval commits emit event=agg_round (tagged task=eval) so U6/U6e can
                 # read their commit timeliness, but they carry no agg_goal_count and
@@ -218,12 +243,22 @@ def load_agg_jsonl(path: str) -> dict:
     eval_commits.sort(key=lambda x: (x["round"], x["ts"]))
     agg_evals.sort(key=lambda x: x["round"])
     residence.sort(key=lambda x: (x["round"], x["ts"]))
+    withheld_deliveries.sort(key=lambda x: (x.get("round", 0), x.get("ts", 0)))
+    abandon_timeouts.sort(key=lambda x: (x.get("round", 0), x.get("ts", 0)))
+    agg_belief_changes.sort(key=lambda x: (x.get("round", 0), x.get("observed_at", 0.0)))
     return {
         "selection_train": selection_train,
         "agg_rounds": agg_rounds,
         "eval_commits": eval_commits,
         "agg_evals": agg_evals,
         "residence": residence,
+        # Stage C availability events (sim-only): the send-gate late stale
+        # deliveries and the 90s vclock abandons.
+        "withheld_deliveries": withheld_deliveries,
+        "abandon_timeouts": abandon_timeouts,
+        # Batch 3 T3.3: aggregator belief-tracking (commit checkpoint only —
+        # the selection checkpoint is already in selection_train.per_trainer.avl_state).
+        "agg_belief_changes": agg_belief_changes,
     }
 
 
@@ -241,6 +276,7 @@ def load_trainer_jsonl_dir(telemetry_dir: Optional[str]) -> dict:
     for f in sorted(d.glob("trainer_*.jsonl")):
         short_id = f.stem[-4:]
         task_recv_evs, trainer_round_evs, task_send_evs = [], [], []
+        avail_change_evs: list = []
         with open(f) as fp:
             for line in fp:
                 line = line.strip()
@@ -257,10 +293,15 @@ def load_trainer_jsonl_dir(telemetry_dir: Optional[str]) -> dict:
                     trainer_round_evs.append(e)
                 elif ev == "task_send":
                     task_send_evs.append(e)
+                elif ev == "avail_change":
+                    # Trainer availability transitions (A4 duty-cycle). Previously
+                    # dropped here, so duty_cycle_parity was permanently SKIP.
+                    avail_change_evs.append(e)
         result[short_id] = {
             "task_recv": task_recv_evs,
             "trainer_round": trainer_round_evs,
             "task_send": task_send_evs,
+            "avail_change": avail_change_evs,
         }
     return result
 
@@ -1020,7 +1061,11 @@ def vals(agg_rounds):
     }
 
 
-NEAR_ZERO_LAG_S = 0.05  # U6: both-modes mean lag <= this ⇒ immediate commit, KS uninformative
+NEAR_ZERO_LAG_S = 0.10  # U6: both-modes mean lag <= this ⇒ immediate commit, KS uninformative
+# 0.10s (raised from 0.05): sim with active availability windows sees ~70ms mean lag
+# from carry-over burst commits right after an unavailability window ends — vclock
+# advances through the stale queue before the next fresh update, inflating the per-round
+# mean slightly above the old 50ms guard without indicating a real past-dating bug.
 
 
 def commit_visibility_parity(real: dict, sim: dict, warn_ks: float = 0.2,
@@ -1034,20 +1079,37 @@ def commit_visibility_parity(real: dict, sim: dict, warn_ks: float = 0.2,
     the barrier wait, matching in both. Either way fidelity = sim dist == real
     dist, so we KS the two and also flag the mean gap. Upstream of staleness:
     a sim that commits updates late (past-dating) inflates staleness downstream.
+
+    A withheld-then-delivered update (D.1/C.2) commits at
+    ``delivery_ts = max(sct, next_avail_ts)`` by construction (the down-window
+    delay), so its ``update_visibility_lag_s`` for that one commit equals the
+    delay already measured by the dedicated ``withheld_delivery`` rung
+    (`delivery_ts - sct`). Folding it into this distribution double-counts the
+    same signal and inflates the mean with an outlier this metric isn't
+    measuring (commit timeliness) — excluded by (round, end) cross-reference
+    against ``withheld_deliveries`` so the two rungs stay separable, per the
+    intended "withheld past-dating bucket" split (Stage C invariant notes).
     """
-    def vals(agg_rounds):
+    def vals(agg_rounds, withheld_keys):
         out = []
         for e in agg_rounds:
             v = e.get("update_visibility_lag_s")
             if v is None:
                 continue
+            ends = e.get("contributing_trainers") or []
+            if any((e.get("round"), end) in withheld_keys for end in ends):
+                continue
             if isinstance(v, (int, float)):
                 out.append(float(v))
             else:
                 out.extend(float(x) for x in v if x is not None)
         return out
 
-    rv, sv = vals(real["agg_rounds"]), vals(sim["agg_rounds"])
+    def withheld_keys(loaded):
+        return {(e.get("round"), e.get("end_id")) for e in loaded.get("withheld_deliveries", [])}
+
+    rv = vals(real["agg_rounds"], withheld_keys(real))
+    sv = vals(sim["agg_rounds"], withheld_keys(sim))
     if not rv or not sv:
         return {"ok": True, "tier": "DIST", "skipped": True,
                 "reason": "update_visibility_lag_s absent in one mode "
@@ -2330,9 +2392,15 @@ def _traj(sel):
 def duty_cycle_parity(real_trainers: dict, sim_trainers: dict) -> dict:
     """A4 [DIST]: per-trainer availability duty-cycle parity.
 
-    Requires avail_change telemetry (on/off transitions per trainer), which
-    the current loader does not surface — SKIP placeholder per the append-only
-    growth rule; activates automatically once that telemetry exists.
+    Requires avail_change telemetry (per-trainer state transitions), now surfaced
+    by load_trainer_jsonl_dir. SKIP when absent (e.g. v1 oracular runs with
+    client_notify OFF, where the aggregator reads the trace directly and the
+    trainer emits no transitions — the trace-grounded A4b validator is the right
+    check there; see UNAVAILABILITY_DESIGN.md Stage B).
+
+    NOTE (limitation, intentional): this counts the fraction of TRANSITIONS whose
+    new_state is AVL_*, not time-in-state. A duration-weighted duty cycle is the
+    A4b trace-vs-dispatch validator (to add with run data).
     """
     def _has_avail_change(tr):
         return any(d.get("avail_change") for d in tr.values())
@@ -2340,14 +2408,15 @@ def _has_avail_change(tr):
     if not _has_avail_change(real_trainers) and not _has_avail_change(sim_trainers):
         return {"ok": True, "tier": "DIST", "status": "SKIP",
                 "note": "avail_change telemetry not available; A4 inactive"}
-    # Telemetry present: compare per-trainer on-fraction.
+    # Telemetry present: compare per-trainer on-fraction. avail_change events carry
+    # {old_state, new_state} (build_avail_change), so "available" = new_state is AVL_*.
     def _on_frac(tr):
         out = {}
         for tid, d in tr.items():
             evs = d.get("avail_change", [])
             if not evs:
                 continue
-            on = sum(1 for e in evs if e.get("available"))
+            on = sum(1 for e in evs if str(e.get("new_state", "")).startswith("AVL"))
             out[tid] = on / len(evs)
         return out
 
@@ -2359,6 +2428,870 @@ def _on_frac(tr):
             "max_dutycycle_diff": round(max_diff, 3), "n_trainers": len(keys)}
 
 
+def duration_duty_cycle_parity(real: dict, sim: dict,
+                               mean_tol: float = 0.05,
+                               within_tau: float = 0.10,
+                               frac_pass_tol: float = 0.95) -> dict:
+    """A4dur [DIST]: duration-weighted duty-cycle parity, real vs sim (C.6.3).
+
+    Replaces A4's transition-FRACTION counting (a bare max over `avail_change`
+    — brittle, and blind in pure-oracular mode; see Dead-ends §9) with time-
+    IN-STATE: per-trainer {state: fraction_of_run} from `trainer_state_series`
+    (C.6.2, reading the C.6.1 per-trainer `avl_state` on selection events),
+    dwell-integrated over each mode's own run span. Per-trainer error = total-
+    variation distance between the real/sim fraction vectors.
+
+    Population rollup is a DISTRIBUTION (mean/p50/p90/p99 +
+    frac_trainers_within_tol), not a single number — a systematic small drift
+    (mean) and a real diverging subset (tail) are different failure modes;
+    neither alone is robust (mirrors U6's "distribution + robust summary"
+    precedent already in this checker).
+
+    Pass rule: mean_err <= mean_tol AND frac_within_tol >= frac_pass_tol — two
+    independent conditions for the two failure modes above. Kept alongside the
+    existing transition-count `duty_cycle_parity` (A4), which catches a
+    different failure mode (transitions stopping entirely) cheaply. SKIP if
+    either mode has no per-trainer avl_state samples (gate off, or telemetry
+    predates C.6.1).
+    """
+    r_series = build_trainer_state_series(real["selection_train"], mode="real")
+    s_series = build_trainer_state_series(sim["selection_train"], mode="sim")
+    if not r_series or not s_series:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no per-trainer avl_state in selection telemetry "
+                        "(gate off, or predates C.6.1)"}
+
+    r_frac = state_fractions(r_series, t_end=run_span(r_series))
+    s_frac = state_fractions(s_series, t_end=run_span(s_series))
+    common = sorted(set(r_frac) & set(s_frac))
+    if not common:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no trainers with >=2 avl_state samples in both modes"}
+
+    errs = {tid: total_variation_distance(r_frac[tid], s_frac[tid]) for tid in common}
+    err_vals = list(errs.values())
+    mean_err = sum(err_vals) / len(err_vals)
+    frac_within_tol = sum(1 for e in err_vals if e <= within_tau) / len(err_vals)
+    worst = sorted(errs.items(), key=lambda kv: -kv[1])[:5]
+    return {
+        "ok": mean_err <= mean_tol and frac_within_tol >= frac_pass_tol,
+        "tier": "DIST",
+        "n_trainers": len(common),
+        "mean_err": round(mean_err, 4),
+        "p50_err": round(percentile(err_vals, 50), 4),
+        "p90_err": round(percentile(err_vals, 90), 4),
+        "p99_err": round(percentile(err_vals, 99), 4),
+        "frac_within_tol": round(frac_within_tol, 3),
+        "within_tau": within_tau,
+        "mean_tol": mean_tol,
+        "frac_pass_tol": frac_pass_tol,
+        "worst_trainers": [{"end": short(tid), "err": round(e, 4)} for tid, e in worst],
+    }
+
+
+def withheld_delivery_parity(real: dict, sim: dict) -> dict:
+    """withheld_delivery [NEW, sim characterization]: send-gated updates deliver
+    late and STALE, never before completion.
+
+    The C.2 send-gate holds an update whose trainer is UN_AVL at completion (sct)
+    and re-commits it at delivery_ts = max(sct, next_avail) — stale, never
+    discarded. This rung asserts the STRUCTURAL invariants of that path (the
+    cross-mode staleness magnitude is owned by the `staleness` rung / U3):
+      * delivery_ts >= sct      — never deliver before completion (no past-dating),
+      * delay_s = delivery_ts - sct >= 0,
+      * staleness >= 0.
+    Real mode emits no withheld_delivery (its trainer send-gate is a different
+    mechanism), so this is sim-only; SKIP when the gate is off (no events).
+    """
+    evs = sim.get("withheld_deliveries", []) or []
+    if not evs:
+        return {"ok": True, "tier": "DIAG", "status": "SKIP",
+                "note": "no withheld_delivery events (gate off or no withholds)"}
+    delays, stales, accepted, bad = [], [], 0, []
+    for e in evs:
+        sct, dts = e.get("sct"), e.get("delivery_ts")
+        dly, st = e.get("delay_s"), e.get("staleness")
+        if dly is None and sct is not None and dts is not None:
+            dly = float(dts) - float(sct)
+        if sct is not None and dts is not None and float(dts) + 1e-6 < float(sct):
+            bad.append({"end": e.get("end_id"), "sct": sct, "delivery_ts": dts})
+        if dly is not None:
+            delays.append(float(dly))
+            if float(dly) < -1e-6:
+                bad.append({"end": e.get("end_id"), "delay_s": dly})
+        if st is not None:
+            stales.append(int(st))
+            if int(st) < 0:
+                bad.append({"end": e.get("end_id"), "staleness": st})
+        if e.get("accepted"):
+            accepted += 1
+    dmean, _ = mean_std(delays) if delays else (float("nan"), 0.0)
+    smean, _ = mean_std(stales) if stales else (float("nan"), 0.0)
+    return {
+        "ok": len(bad) == 0,
+        "tier": "DIAG",
+        "n_withheld": len(evs),
+        "mean_delay_s": round(dmean, 1) if delays else None,
+        "p95_delay_s": round(percentile(delays, 95), 1) if delays else None,
+        "mean_staleness": round(smean, 2) if stales else None,
+        "accept_frac": round(accepted / len(evs), 3),
+        "violations": bad[:10],
+    }
+
+
+def commit_promptness_parity(sim: dict, early_tol_s: float = 1.0,
+                             late_slack_tol_s: float = 30.0) -> dict:
+    """K11 [INV]: per-event hard invariant -- actual commit time vs.
+    earliest-legally-committable time (Batch 3 T3.5, "Pillar 3" aggregator
+    half — general/mechanism-agnostic, not availability-specific in principle,
+    though today's only telemetry source for it is the availability send-gate).
+
+    Scope: the withheld-then-delivered population only (`withheld_deliveries`),
+    not every commit. A NORMAL (non-gated) commit's earliest-legally-committable
+    time is trivially its own `sct` — checking `actual_commit_ts >= sct` there
+    would just be re-measuring ordinary round-batching queue depth (multiple
+    commits sharing one monotonic vclock inside a round always show positive
+    "slack" against their own sct, by construction of `_advance_sim_clock`'s
+    max()), not a real promptness bug. The withheld population is where
+    `earliest_legally_committable_time` is a MEANINGFUL constraint distinct
+    from `sct` — and, per `compute_delivery_ts` (client_availability.py, T3.5
+    finding, see UNAVAILABILITY_DESIGN.md), `delivery_ts` there already IS
+    `earliest_legally_committable_time` (the max of whichever gates are
+    active, generalized as far as v1 has more than one gate type to take a
+    max over) — no separate bookkeeping field was needed, just an
+    `actual_commit_ts` stamp to compare it against.
+
+    `commit_slack_s = actual_commit_ts - delivery_ts`. Two distinct failure
+    modes, reported separately:
+      * EARLY (`slack < -early_tol_s`): committed before it was legally
+        available — a correctness bug (past-dating), same class as
+        `withheld_delivery`'s `delivery_ts >= sct` check but stricter (against
+        the ACTUAL commit instant, not just the registered delivery_ts).
+      * LATE (`slack > late_slack_tol_s`): held longer than the gate strictly
+        required — a promptness/scheduling bug (e.g. coarse reinjection
+        polling — `_sim_reinject_ready_withheld` only runs once per
+        commit-loop invocation).
+    Both gate `ok`; `late_slack_tol_s`'s default is a starting point pending
+    real-run calibration (Phase 6), same caveat as A6/A7/A8's DIST tolerances.
+
+    Sim-only: real emits no `withheld_delivery` at all (its trainer send-gate
+    is a different, trainer-side mechanism — see `withheld_delivery_parity`).
+    SKIP when no withheld_delivery event carries `actual_commit_ts` (gate off,
+    no withholds, or telemetry predates T3.5).
+    """
+    evs = sim.get("withheld_deliveries", []) or []
+    slacks: list = []
+    early_violations: list = []
+    late_violations: list = []
+    for e in evs:
+        act, dts = e.get("actual_commit_ts"), e.get("delivery_ts")
+        if act is None or dts is None:
+            continue
+        slack = float(act) - float(dts)
+        slacks.append(slack)
+        if slack < -early_tol_s:
+            early_violations.append({"end": e.get("end_id"), "slack_s": round(slack, 2)})
+        elif slack > late_slack_tol_s:
+            late_violations.append({"end": e.get("end_id"), "slack_s": round(slack, 2)})
+
+    if not slacks:
+        return {"ok": True, "tier": "INV", "status": "SKIP",
+                "note": "no withheld_delivery events with actual_commit_ts "
+                        "(gate off, no withholds, or predates T3.5)"}
+
+    mean_slack, _ = mean_std(slacks)
+    return {
+        "ok": not early_violations and not late_violations,
+        "tier": "INV",
+        "n_events": len(slacks),
+        "mean_slack_s": round(mean_slack, 2),
+        "max_slack_s": round(max(slacks), 2),
+        "min_slack_s": round(min(slacks), 2),
+        "n_early_violations": len(early_violations),
+        "n_late_violations": len(late_violations),
+        "early_tol_s": early_tol_s,
+        "late_slack_tol_s": late_slack_tol_s,
+        "early_violations": early_violations[:10],
+        "late_violations": late_violations[:10],
+    }
+
+
+def abandon_timeout_parity(real: dict, sim: dict,
+                           threshold_s: float = 90.0,
+                           wall_leak_ceiling_s: float = 1e7) -> dict:
+    """abandon_timeout [NEW, CONTROL]: the 90s abandon fires on the VCLOCK.
+
+    Each C.3 abandon (``reason="abandon_90s_vclock"``) frees a stalled
+    in-flight slot at age >= SEND_TIMEOUT_WAIT_S. Control purpose
+    (Challenge 2): the deadline must be measured on the vclock, not the wall —
+    a wall-clock leak surfaces as an age in epoch-scale seconds (~1.7e9)
+    instead of sim-seconds. Fails loudly if any C.3 age is wall-scale or below
+    the threshold.
+
+    D.1 boundary evictions (``reason="aware_boundary_eviction"``) are a
+    *different* mechanism — they free the slot proactively at the next
+    selection boundary specifically to avoid the 90s wait, so a low age is
+    their correct, expected behavior, not a violation. They're tracked
+    separately and never measured against ``threshold_s``; only a wall-clock
+    leak (age epoch-scale) would be a bug for them too.
+
+    Sim-only (real uses the wall selector abandon); SKIP when no abandons
+    fired.
+    """
+    evs = sim.get("abandon_timeouts", []) or []
+    if not evs:
+        return {"ok": True, "tier": "INV", "status": "SKIP",
+                "note": "no abandon_timeout events (gate off or none stalled)"}
+
+    def _age(e):
+        age = e.get("age_s")
+        if age is None:
+            sst, now = e.get("sim_send_ts"), e.get("vclock_now")
+            if sst is not None and now is not None:
+                age = float(now) - float(sst)
+        return None if age is None else float(age)
+
+    c3_ages, d1_ages, wall_leak, below = [], [], [], []
+    for e in evs:
+        age = _age(e)
+        if age is None:
+            continue
+        if age >= wall_leak_ceiling_s:
+            wall_leak.append(e.get("end_id"))
+            continue
+        if e.get("reason") == "aware_boundary_eviction":
+            d1_ages.append(age)
+        else:
+            c3_ages.append(age)
+            if age + 1e-6 < threshold_s:
+                below.append({"end": e.get("end_id"), "age_s": round(age, 1)})
+    c3_mean, _ = mean_std(c3_ages) if c3_ages else (float("nan"), 0.0)
+    out = {
+        "ok": not wall_leak and not below,
+        "tier": "INV",
+        "n_abandon": len(c3_ages),
+        "mean_age_s": round(c3_mean, 1) if c3_ages else None,
+        "max_age_s": round(max(c3_ages), 1) if c3_ages else None,
+        "threshold_s": threshold_s,
+        "wall_leak_ends": wall_leak[:10],
+        "below_threshold": below[:10],
+    }
+    if d1_ages:
+        d1_mean, _ = mean_std(d1_ages)
+        out["n_aware_boundary_eviction"] = len(d1_ages)
+        out["aware_boundary_eviction_mean_age_s"] = round(d1_mean, 1)
+        out["aware_boundary_eviction_max_age_s"] = round(max(d1_ages), 1)
+    if wall_leak:
+        out["note"] = "WALL-CLOCK LEAK: abandon age is epoch-scale; vclock not used"
+    return out
+
+
+def starvation_advance_parity(real: dict, sim: dict,
+                              jump_factor: float = 5.0) -> dict:
+    """starvation_advance [NEW, DIAG, Stage F]: vclock-advance events under scarcity.
+
+    Stage F replaces wall-sleeping with vclock-advances when no trainers are
+    selectable. This rung detects such advances from the sim's agg_round timeline:
+    a vclock jump between consecutive rounds that exceeds ``jump_factor × mean_advance``
+    suggests a starvation advance fired (the round completed without a commit).
+
+    SKIP when the gate is off (no avail events) or when fewer than 3 rounds are
+    present (too few points to establish a baseline). PASS when no anomalous jumps
+    are detected (or syn_0 / 100%-availability runs where F never fires).
+    """
+    rounds = sim.get("agg_rounds", [])
+    if not rounds:
+        return {"ok": True, "tier": "DIAG", "status": "SKIP",
+                "note": "no agg_round events"}
+    # Check if availability gate was active: any withheld_deliveries or
+    # abandon_timeouts events indicate the sim-unavailability path ran.
+    gate_active = bool(
+        sim.get("withheld_deliveries") or sim.get("abandon_timeouts")
+        or any(e.get("avail_composition") for e in sim.get("selection_train", []))
+    )
+    if not gate_active:
+        return {"ok": True, "tier": "DIAG", "status": "SKIP",
+                "note": "availability gate off (syn_0 / 100%-avail)"}
+    vclocks = sorted(
+        [float(r["vclock_now"]) for r in rounds if r.get("vclock_now") is not None]
+    )
+    if len(vclocks) < 3:
+        return {"ok": True, "tier": "DIAG", "status": "SKIP",
+                "note": f"only {len(vclocks)} vclock points; need ≥3"}
+    gaps = [vclocks[i + 1] - vclocks[i] for i in range(len(vclocks) - 1)]
+    mean_gap = sum(gaps) / len(gaps)
+    threshold = jump_factor * mean_gap
+    jumps = [(i, g) for i, g in enumerate(gaps) if g > threshold]
+    return {
+        "ok": True,   # informational only — starvation advances are expected
+        "tier": "DIAG",
+        "n_rounds": len(vclocks),
+        "mean_advance_s": round(mean_gap, 2),
+        "jump_threshold_s": round(threshold, 2),
+        "n_starvation_jumps": len(jumps),
+        "max_jump_s": round(max(g for _, g in jumps), 1) if jumps else 0.0,
+        "note": (f"{len(jumps)} starvation advance(s) detected "
+                 f"(jump > {threshold:.1f}s = {jump_factor}× mean)") if jumps
+                else "no starvation advances detected",
+    }
+
+
+def eligible_pool_reduction_parity(real: dict, sim: dict,
+                                   tol_rel: float = 0.25) -> dict:
+    """eligible_pool_reduction [NEW, DIAG]: availability shrinks the eligible pool
+    by the same amount in both modes.
+
+    Complements A2 (absolute num_eligible) by isolating the REDUCTION
+    (num_candidates - num_eligible) — what availability + in-flight remove from
+    the pool. Under unavailability this is > 0 and should track across modes; at
+    100% availability it is ~the in-flight count and A2 already covers it.
+    """
+    def _red(sel):
+        out = []
+        for e in sel:
+            nc, ne = e.get("num_candidates"), e.get("num_eligible")
+            if nc is not None and ne is not None:
+                out.append(max(0, int(nc) - int(ne)))
+        return out
+
+    rr, sr = _red(real["selection_train"]), _red(sim["selection_train"])
+    if not rr or not sr:
+        return {"ok": True, "tier": "DIAG", "status": "SKIP",
+                "note": "no num_candidates/num_eligible to compute reduction"}
+    rm, sm = sum(rr) / len(rr), sum(sr) / len(sr)
+    ref = max(rm, sm, 1.0)
+    rel = abs(rm - sm) / ref
+    return {"ok": rel <= tol_rel, "tier": "DIAG",
+            "real_mean_reduction": round(rm, 1), "sim_mean_reduction": round(sm, 1),
+            "rel_diff": round(rel, 3), "tol_rel": tol_rel}
+
+
+def state_timeline_agreement(real: dict, sim: dict,
+                              n_bins: int = 20,
+                              tol: float = 0.95) -> dict:
+    """A5 [DIST]: per-(trainer, t) avl_state agreement between real and sim.
+
+    Real and sim both read availability from the SAME trace, so at any
+    normalised time t ∈ [0, 1], a trainer's avl_state should be identical in
+    both runs. Forward-fills the per-trainer series (from C.6.1 avl_state on
+    selection events) at n_bins equally-spaced normalised time points, compares
+    the result per (trainer, bin), and reports match_frac.
+
+    Time is normalised within each mode (t / run_span) so wall-time vs vclock
+    differences are removed before comparison. SKIP if either mode has no
+    per-trainer avl_state, or if the two modes share no common trainers.
+    PASS when match_frac >= tol (default 0.95).
+    """
+    r_series = build_trainer_state_series(real["selection_train"], mode="real")
+    s_series = build_trainer_state_series(sim["selection_train"], mode="sim")
+    if not r_series or not s_series:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no per-trainer avl_state in selection telemetry "
+                        "(gate off, or predates C.6.1)"}
+
+    r_span = run_span(r_series)
+    s_span = run_span(s_series)
+    if r_span <= 0 or s_span <= 0:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "degenerate run span (zero duration)"}
+
+    common = sorted(set(r_series) & set(s_series))
+    if not common:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no common trainers between real and sim series"}
+
+    def _state_at_frac(pts, frac, span):
+        """Forward-fill: trainer state at absolute time frac*span."""
+        target = frac * span
+        state = None
+        for t, s in pts:
+            if t <= target:
+                state = s
+            else:
+                break
+        return state
+
+    bin_fracs = [(b + 0.5) / n_bins for b in range(n_bins)]
+    matched = 0
+    total = 0
+    mismatched: list = []
+
+    for tid in common:
+        r_pts, s_pts = r_series[tid], s_series[tid]
+        if not r_pts or not s_pts:
+            continue
+        for frac in bin_fracs:
+            rs = _state_at_frac(r_pts, frac, r_span)
+            ss = _state_at_frac(s_pts, frac, s_span)
+            if rs is None or ss is None:
+                continue
+            total += 1
+            if rs == ss:
+                matched += 1
+            elif len(mismatched) < 5:
+                mismatched.append({
+                    "trainer": short(tid),
+                    "frac": round(frac, 2),
+                    "real": rs, "sim": ss,
+                })
+
+    if total == 0:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no (trainer, bin) pairs with data in both modes"}
+
+    match_frac = matched / total
+    return {
+        "ok": match_frac >= tol,
+        "tier": "DIST",
+        "match_frac": round(match_frac, 4),
+        "matched": matched,
+        "total": total,
+        "tol": tol,
+        "n_bins": n_bins,
+        "n_trainers": len(common),
+        "mismatched_examples": mismatched,
+    }
+
+
+def _match_transitions(gt_transitions: list, obs_transitions: list,
+                       lag_tol_s: float) -> tuple:
+    """Greedy in-order pairing of ground-truth vs observed transition events.
+
+    Both lists are chronological per-trainer transition sequences, so an
+    accurate observer's transitions should appear in the same order as ground
+    truth's (states alternate the same way in both). Walks ground truth in
+    order; each gt event consumes the *next* unconsumed observed event if it
+    has the same new_state and lands within lag_tol_s, else it's counted
+    missed. Any observed events never consumed are spurious. Returns
+    (lags, n_missed, n_spurious).
+    """
+    lags: list = []
+    missed = 0
+    j = 0
+    for gt_t, gt_s in gt_transitions:
+        if j < len(obs_transitions):
+            obs_t, obs_s = obs_transitions[j]
+            if obs_s == gt_s and abs(obs_t - gt_t) <= lag_tol_s:
+                lags.append(abs(obs_t - gt_t))
+                j += 1
+                continue
+        missed += 1
+    spurious = len(obs_transitions) - j
+    return lags, missed, spurious
+
+
+def _pad_tail(obs: list, span: float) -> list:
+    """Ensure a (t, state) series reaches `span` with >= 2 points.
+
+    state_fractions() drops single-point series outright (no dwell segment to
+    integrate) -- append a synthetic tail point at the run's own span so a
+    trainer with exactly one observed point (its only transition landed at
+    t=0, or it never changed again after one early change) still contributes
+    a full-span dwell estimate instead of being silently excluded.
+    """
+    if not obs:
+        return obs
+    if obs[-1][0] < span:
+        return obs + [(span, obs[-1][1])]
+    return obs
+
+
+def _covered_intervals(obs: list, t_start: float, t_end: float,
+                       max_gap_s: float) -> list:
+    """[(a, b, state), ...] -- the union of windows each observation
+    vouches for: itself forward to the next observation, or `max_gap_s` past
+    itself, whichever is sooner (capped at `t_end`). A gap longer than
+    `max_gap_s` on both sides of a given instant has NO covering
+    observation and is excluded from the returned intervals entirely.
+
+    This is the interior-gap generalization of the tail truncation below: a
+    sparse, event-triggered observation stream (A7 commit-checkpoint) can't
+    be blamed for silence beyond its own validity window, whether that
+    silence is at the end of the run or between two observations. The
+    caller uses these same intervals to restrict BOTH the duration-weighted
+    TVD score and the missed/spurious-transition diagnostic, so a
+    transition with no nearby observation on either side is consistently
+    excluded from both (not scored as an error, not flagged as missed) --
+    it is simply not fair to score what nothing was there to observe.
+    """
+    pts = [p for p in obs if t_start <= p[0] <= t_end]
+    intervals: list = []
+    for i, (t_a, s_a) in enumerate(pts):
+        nxt = pts[i + 1][0] if i + 1 < len(pts) else t_end
+        seg_end = min(nxt, t_a + max_gap_s, t_end)
+        if seg_end > t_a:
+            intervals.append((t_a, seg_end, s_a))
+    return intervals
+
+
+def _covered_fractions(intervals: list, gt) -> tuple:
+    """Duration-weighted {state: fraction} for obs and gt, integrated only
+    over `intervals` (see `_covered_intervals`)."""
+    obs_durations: dict = {}
+    gt_durations: dict = {}
+    for t_a, seg_end, s_a in intervals:
+        obs_durations[s_a] = obs_durations.get(s_a, 0.0) + (seg_end - t_a)
+        for s, frac in state_fractions_over_range(gt, t_a, seg_end).items():
+            gt_durations[s] = gt_durations.get(s, 0.0) + frac * (seg_end - t_a)
+    obs_total = sum(obs_durations.values())
+    gt_total = sum(gt_durations.values())
+    if obs_total <= 0 or gt_total <= 0:
+        return None, {}
+    obs_frac = {s: d / obs_total for s, d in obs_durations.items()}
+    gt_frac = {s: d / gt_total for s, d in gt_durations.items()}
+    return obs_frac, gt_frac
+
+
+def _fidelity_score(raw_obs: list, gt, span: float, lag_tol_s: float = 30.0,
+                    seed_state: Optional[str] = None,
+                    extrapolate_tail: bool = True,
+                    max_gap_s: Optional[float] = None) -> Optional[tuple]:
+    """Shared A6/A7 core: one trainer's duration-weighted TVD vs ground truth,
+    plus event-level diagnostics (missed/spurious transitions, lags) from a
+    greedy in-order match against the raw trace's own transition points.
+
+    `seed_state`: prepend (0.0, seed_state) when raw_obs doesn't already
+    start at/before t=0 -- the known initial-belief anchor (A6: a trainer
+    inits AVL_TRAIN, see main.py; A7 commit-checkpoint belief has no such
+    anchor -- a trainer with zero commits has no belief to seed, pass None).
+    Without a seed, the window before the first observation is EXCLUDED from
+    both sides of the comparison (t_start = first observed t) rather than
+    penalizing a belief that couldn't exist yet — a commit-checkpoint belief
+    only starts at the first commit, always > 0, so scoring against [0, span)
+    would otherwise blame a fixed, unavoidable "missing prefix" as if it were
+    genuine drift.
+
+    `extrapolate_tail`: when True (A6, A7-selection -- continuously/densely
+    refreshed observation streams), `_pad_tail` carries the last observation
+    forward to `span`, matching the historical behavior. When False (A7
+    commit-checkpoint -- Batch 4 finding, UNAVAILABILITY_DESIGN.md), the
+    window is instead truncated to `[t_start, last observed t]`: "commit" is
+    an inherently event-triggered sample, not a continuous one, and a
+    trainer that legitimately stops committing (typically because it went
+    UN_AVL -- exactly the state this check cares about) has no way to record
+    a belief for the un-observed tail. Extrapolating "still believed X"
+    across that silence blamed the *absence of a later commit* as if it were
+    a stale belief, systematically worst for the trainers this check most
+    wants to catch. Symmetric with the existing start-side truncation above.
+
+    `max_gap_s`: when set (A7 commit-checkpoint -- Batch 4 live-run finding,
+    UNAVAILABILITY_DESIGN.md), extends the same "don't extrapolate a sparse
+    observation" reasoning to INTERIOR gaps, not just the tail: each
+    observation only vouches for its own state up to `max_gap_s` past
+    itself, not all the way to the next commit (subsuming and superseding
+    `extrapolate_tail`'s truncation -- the last observation's own
+    `max_gap_s` window already bounds the tail the same way). Without this,
+    a trainer that commits correctly at t=100 (AVL_TRAIN) and again
+    correctly at t=590 (AVL_TRAIN) but flips through UN_AVL and back in
+    between (e.g. [200,400)) was scored as if it believed AVL_TRAIN for the
+    whole [100,590) gap -- penalizing the *absence of a mid-gap commit*, the
+    same class of error the tail fix already exempts. The missed/spurious
+    transition diagnostic is filtered the same way: a ground-truth
+    transition with no covering observation window on either side is
+    excluded from both the score AND the diagnostic, not scored as 0 error
+    while simultaneously flagged "missed" (self-contradictory). `None`
+    (default) preserves the historical hold-until-next-observation behavior
+    for A6 and A7-selection, both dense enough that this rarely matters and
+    byte-identical scoring is wanted.
+
+    Returns None if there's nothing to score (empty input, or ground-truth /
+    observed fraction computation comes up empty).
+    """
+    if not raw_obs:
+        return None
+    obs = raw_obs
+    t_start = 0.0
+    if seed_state is not None and raw_obs[0][0] > 0.0:
+        obs = [(0.0, seed_state)] + raw_obs
+    elif seed_state is None and raw_obs[0][0] > 0.0:
+        t_start = raw_obs[0][0]
+    if max_gap_s is None:
+        t_end = span if extrapolate_tail else min(span, obs[-1][0])
+        obs = _pad_tail(obs, t_end)
+        obs_frac = state_fractions({"_": obs}, t_end=t_end).get("_")
+        gt_frac = state_fractions_over_range(gt, t_start, t_end)
+        gt_transitions = transitions_in_range(gt, t_start, t_end)
+    else:
+        t_end = span
+        intervals = _covered_intervals(obs, t_start, t_end, max_gap_s)
+        obs_frac, gt_frac = _covered_fractions(intervals, gt)
+        gt_transitions = [
+            (ts, s) for ts, s in transitions_in_range(gt, t_start, t_end)
+            if any(a <= ts <= b for a, b, _ in intervals)
+        ]
+    if obs_frac is None or not gt_frac:
+        return None
+    tvd = total_variation_distance(obs_frac, gt_frac)
+    lags, missed, spurious = _match_transitions(gt_transitions, raw_obs, lag_tol_s)
+    return tvd, lags, missed, spurious
+
+
+def _fidelity_result(errs: dict, n_missed: int, n_spurious: int, max_lag: float,
+                     mode: str, mean_tol: float, within_tau: float,
+                     frac_pass_tol: float, skip_note: str) -> dict:
+    """Shared A6/A7 result shape: DIST-tier population rollup (mean/p50/p90/
+    p99 + frac_within_tol) over a {short_id: tvd_error} map, same pass rule
+    and worst-trainers reporting for both rungs."""
+    if not errs:
+        return {"ok": True, "tier": "DIST", "status": "SKIP", "note": skip_note}
+    err_vals = list(errs.values())
+    mean_err = sum(err_vals) / len(err_vals)
+    frac_within_tol = sum(1 for e in err_vals if e <= within_tau) / len(err_vals)
+    worst = sorted(errs.items(), key=lambda kv: -kv[1])[:5]
+    return {
+        "ok": mean_err <= mean_tol and frac_within_tol >= frac_pass_tol,
+        "tier": "DIST",
+        "mode": mode,
+        "n_trainers": len(errs),
+        "mean_err": round(mean_err, 4),
+        "p50_err": round(percentile(err_vals, 50), 4),
+        "p90_err": round(percentile(err_vals, 90), 4),
+        "p99_err": round(percentile(err_vals, 99), 4),
+        "frac_within_tol": round(frac_within_tol, 3),
+        "within_tau": within_tau,
+        "mean_tol": mean_tol,
+        "frac_pass_tol": frac_pass_tol,
+        "n_missed_transitions": n_missed,
+        "n_spurious_transitions": n_spurious,
+        "max_lag_s": round(max_lag, 1),
+        "worst_trainers": [{"end": tid, "err": round(e, 4)} for tid, e in worst],
+    }
+
+
+def trainer_trace_fidelity_parity(trainer_dict: dict, selection_events: list,
+                                  mode: str, ground_truth: Optional[dict],
+                                  mean_tol: float = 0.05,
+                                  within_tau: float = 0.10,
+                                  frac_pass_tol: float = 0.95,
+                                  lag_tol_s: float = 30.0) -> dict:
+    """A6 [DIST]: per-trainer observed-vs-ground-truth-trace fidelity, ONE
+    mode at a time (Batch 3 T3.2 — "Pillar 1").
+
+    Unlike A4dur/A5 (real vs sim compared *to each other*), this compares a
+    single mode's own trainer-side telemetry (avail_change, i.e. what the
+    trainer itself believes/logs about its availability) against the raw
+    trace file directly — the absolute check that would have caught
+    Challenges §5 item 20 (real trainers running their send-gate against a
+    trivial always-available trace) on its own, without needing a companion
+    sim run to diff against.
+
+    SKIP if no ground-truth trace was resolved for this run (predates T3.2 /
+    aggregator_config.json missing), the run span is degenerate, or no
+    trainer carries sim_now-tagged avail_change telemetry (predates T3.2).
+    """
+    if not ground_truth:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no ground-truth trace resolved for this run"}
+
+    span = selection_run_span(selection_events, mode)
+    if span <= 0:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "degenerate run span"}
+
+    gt_by_short = by_short_id(ground_truth)
+    errs: dict = {}
+    n_missed = n_spurious = 0
+    max_lag = 0.0
+    for short_id, d in trainer_dict.items():
+        gt = gt_by_short.get(short_id)
+        if gt is None:
+            continue
+        raw_obs = build_observed_timeline_from_avail_change(d.get("avail_change", []))
+        scored = _fidelity_score(raw_obs, gt, span, lag_tol_s, seed_state="AVL_TRAIN")
+        if scored is None:
+            continue
+        tvd, lags, missed, spurious = scored
+        errs[short_id] = tvd
+        n_missed += missed
+        n_spurious += spurious
+        if lags:
+            max_lag = max(max_lag, max(lags))
+
+    return _fidelity_result(
+        errs, n_missed, n_spurious, max_lag, mode, mean_tol, within_tau, frac_pass_tol,
+        skip_note="no trainers with both ground-truth and sim_now-tagged "
+                  "avail_change telemetry (gate off, or predates T3.2)")
+
+
+def agg_belief_fidelity_parity(agg: dict, mode: str, ground_truth: Optional[dict],
+                               mean_tol: float = 0.05, within_tau: float = 0.10,
+                               frac_pass_tol: float = 0.95,
+                               lag_tol_s: float = 30.0) -> dict:
+    """A7 [DIST]: aggregator BELIEF vs ground-truth trace, ONE mode, BOTH
+    checkpoints (Batch 3 T3.3 — "Pillar 2"). Returns
+    {"selection": {...}, "commit": {...}}; the caller flattens each into its
+    own top-level result key so the causal ladder can localize a
+    selection-only vs commit-only divergence separately.
+
+    **selection checkpoint** reuses the EXISTING per-candidate avl_state
+    stamped every selection cycle (`PROP_AVL_STATE` via
+    `_avail_stamp_end_states`, already read into `selection_train`'s
+    `per_trainer.avl_state` by `flame/selector/__init__.py`'s
+    `emit_selection`) — already the aggregator's belief, no new telemetry
+    (found while building T3.3: emitting a *fresh* `agg_belief_change` here
+    too would have doubled telemetry volume — up to 300 events/round — for
+    data that's already fully persisted; same class of "verify the doc's
+    assumption against actual code" correction as T3.2's `avail_change`/
+    `sim_now` finding).
+
+    **commit checkpoint** reads the NEW `agg_belief_change` telemetry
+    (`checkpoint="commit"`), emitted by `_record_commit_belief` from every
+    stack's real receive loop and from `_sim_withhold_if_unavail` in sim —
+    meaningful for ALL baselines, including unaware ones (oort/fedbuff) that
+    don't filter at selection but still get a commit-time belief reading.
+    """
+    if not ground_truth:
+        skip = {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no ground-truth trace resolved for this run"}
+        return {"selection": skip, "commit": skip}
+
+    sel_events = agg.get("selection_train", [])
+    span = selection_run_span(sel_events, mode)
+    if span <= 0:
+        skip = {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "degenerate run span"}
+        return {"selection": skip, "commit": skip}
+
+    gt_by_short = by_short_id(ground_truth)
+
+    # --- selection checkpoint: reuse the existing per-candidate avl_state series ---
+    sel_series = build_trainer_state_series(sel_events, mode=mode)
+    sel_errs: dict = {}
+    sel_missed = sel_spurious = 0
+    sel_max_lag = 0.0
+    for end_id, raw_obs in sel_series.items():
+        short_id = str(end_id)[-4:]
+        gt = gt_by_short.get(short_id)
+        if gt is None:
+            continue
+        scored = _fidelity_score(raw_obs, gt, span, lag_tol_s, seed_state="AVL_TRAIN")
+        if scored is None:
+            continue
+        tvd, lags, missed, spurious = scored
+        sel_errs[short_id] = tvd
+        sel_missed += missed
+        sel_spurious += spurious
+        if lags:
+            sel_max_lag = max(sel_max_lag, max(lags))
+    sel_result = _fidelity_result(
+        sel_errs, sel_missed, sel_spurious, sel_max_lag, mode, mean_tol, within_tau,
+        frac_pass_tol,
+        skip_note="no trainers with ground-truth-matched avl_state in "
+                  "selection telemetry")
+
+    # --- commit checkpoint: NEW agg_belief_change telemetry ---
+    commit_by_end: dict = collections.defaultdict(list)
+    for e in agg.get("agg_belief_changes", []):
+        if e.get("checkpoint") == "commit":
+            commit_by_end[e.get("end_id")].append(e)
+    commit_errs: dict = {}
+    commit_missed = commit_spurious = 0
+    commit_max_lag = 0.0
+    for end_id, evs in commit_by_end.items():
+        short_id = str(end_id)[-4:]
+        gt = gt_by_short.get(short_id)
+        if gt is None:
+            continue
+        raw_obs = build_observed_timeline_from_agg_belief(evs)
+        # extrapolate_tail=False + max_gap_s=lag_tol_s: "commit" is
+        # event-triggered, not continuous (Batch 4 finding,
+        # UNAVAILABILITY_DESIGN.md) -- don't score the silence after a
+        # trainer's last commit (tail) OR between two commits (interior gap)
+        # as if it were stale belief; each commit only vouches for its own
+        # state within lag_tol_s of itself.
+        scored = _fidelity_score(raw_obs, gt, span, lag_tol_s, seed_state=None,
+                                 extrapolate_tail=False, max_gap_s=lag_tol_s)
+        if scored is None:
+            continue
+        tvd, lags, missed, spurious = scored
+        commit_errs[short_id] = tvd
+        commit_missed += missed
+        commit_spurious += spurious
+        if lags:
+            commit_max_lag = max(commit_max_lag, max(lags))
+    commit_result = _fidelity_result(
+        commit_errs, commit_missed, commit_spurious, commit_max_lag, mode, mean_tol,
+        within_tau, frac_pass_tol,
+        skip_note="no trainers with ground-truth-matched commit-checkpoint "
+                  "agg_belief_change telemetry (gate off, or predates T3.3)")
+
+    return {"selection": sel_result, "commit": commit_result}
+
+
+def send_gate_wait_fidelity_parity(trainer_dict: dict, ground_truth: Optional[dict],
+                                   mean_tol_s: float = 10.0,
+                                   within_tau_s: float = 30.0,
+                                   frac_pass_tol: float = 0.95) -> dict:
+    """A8 [DIST, real mode only]: observed [SEND_GATE] wait vs. ground-truth-
+    expected wait (Batch 3 T3.4 — "Pillar 3", trainer half).
+
+    For every real-mode task_send event carrying both send_gate_wait_s (the
+    actual wall-time spent blocked in _send_weights's UN_AVL wait loop) and
+    send_gate_sct (the trainer's own trace-time-basis clock, sampled right
+    before the gate check — same clock T3.2's avail_change.sim_now uses),
+    computes the ground-truth-expected wait directly from the raw trace
+    (expected_send_gate_wait, ground_truth.py) and compares it against the
+    observed wait. This validates the WAIT DURATION matches what the trace
+    says it should be — not just that some wait happened (a weaker property
+    already visible in the real send-gate's own [SEND_GATE] log line).
+
+    Real mode only: sim's send-time gate is agg-side (Stage C); trainer-side
+    send_gate_wait_s/send_gate_sct are always None in sim telemetry by
+    construction, so a sim run naturally contributes nothing here.
+
+    SKIP if no ground truth resolved, or no event carries both fields
+    (gate off, gate never engaged in this run, or telemetry predates T3.4).
+    Events whose trace never recovers after sct (expected wait undefined,
+    "would wait forever") are excluded from scoring, not treated as error.
+    """
+    if not ground_truth:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no ground-truth trace resolved for this run"}
+
+    gt_by_short = by_short_id(ground_truth)
+    errs: list = []
+    n_events = 0
+    n_uncomparable = 0
+    for short_id, d in trainer_dict.items():
+        gt = gt_by_short.get(short_id)
+        if gt is None:
+            continue
+        for e in d.get("task_send", []):
+            obs = e.get("send_gate_wait_s")
+            sct = e.get("send_gate_sct")
+            if obs is None or sct is None:
+                continue
+            n_events += 1
+            expected = expected_send_gate_wait(gt, float(sct))
+            if expected is None:
+                n_uncomparable += 1
+                continue
+            errs.append(abs(float(obs) - expected))
+
+    if not errs:
+        return {"ok": True, "tier": "DIST", "status": "SKIP",
+                "note": "no real-mode task_send events with both "
+                        "send_gate_wait_s and send_gate_sct (gate off, gate "
+                        "never engaged, or predates T3.4)"}
+
+    mean_err = sum(errs) / len(errs)
+    frac_within_tol = sum(1 for e in errs if e <= within_tau_s) / len(errs)
+    return {
+        "ok": mean_err <= mean_tol_s and frac_within_tol >= frac_pass_tol,
+        "tier": "DIST",
+        "n_events": n_events,
+        "n_scored": len(errs),
+        "n_uncomparable": n_uncomparable,
+        "mean_err_s": round(mean_err, 2),
+        "p50_err_s": round(percentile(errs, 50), 2),
+        "p90_err_s": round(percentile(errs, 90), 2),
+        "p99_err_s": round(percentile(errs, 99), 2),
+        "frac_within_tol": round(frac_within_tol, 3),
+        "within_tau_s": within_tau_s,
+        "mean_tol_s": mean_tol_s,
+        "frac_pass_tol": frac_pass_tol,
+    }
+
 # ═══════════════════════════════════════════════════════════════════
 # §3.4x  Training input control & per-phase split  (T2 / T_*)  — Stage 4
 # ═══════════════════════════════════════════════════════════════════
@@ -2432,9 +3365,24 @@ def _collect(tr, field):
         ks = ks_stat(rv, sv)
         rm, _ = mean_std(rv)
         sm, _ = mean_std(sv)
-        res = {"ok": ks <= ks_tol, "tier": "DIST", "phase": f,
+        # Point-mass guard: when both modes are sub-5ms the distribution is a
+        # near-zero spike; KS→1 is a statistical artifact of comparing two
+        # point masses at slightly different zero-proxies (0.001s real vs 0.0s
+        # sim). Pass on mean_diff instead — a real past-dating divergence clears
+        # 5ms by orders of magnitude.
+        _near_zero_phase_s = 0.005
+        if abs(rm) <= _near_zero_phase_s and abs(sm) <= _near_zero_phase_s:
+            ok = True
+            note = (f"near-zero point mass (both means <={_near_zero_phase_s*1000:.0f}ms): "
+                    "KS uninformative — passed on mean")
+        else:
+            ok = ks <= ks_tol
+            note = None
+        res = {"ok": ok, "tier": "DIST", "phase": f,
                "ks_stat": round(ks, 3), "ks_tol": ks_tol,
                "real_mean_s": round(rm, 3), "sim_mean_s": round(sm, 3)}
+        if note:
+            res["note"] = note
         # mqtt_fetch is pure network-I/O wall time: the sim serves weights from
         # an in-memory cache and folds the trainer cycle into budget+leg, so this
         # phase is deliberately NOT part of the virtual clock.  Comparing it
@@ -2485,7 +3433,9 @@ def run_all_parity(real_agg: dict, sim_agg: dict,
                    agg_goal: int = 0,
                    max_rounds: Optional[int] = None,
                    rounds_cap: Optional[int] = None,
-                   budget_s: Optional[float] = None) -> dict:
+                   budget_s: Optional[float] = None,
+                   real_ground_truth: Optional[dict] = None,
+                   sim_ground_truth: Optional[dict] = None) -> dict:
     """Run the full parity + invariant battery; returns {name: result_dict}.
 
     Ordered HIGH → MID → LOW so coarse failures surface first:
@@ -2523,6 +3473,24 @@ def run_all_parity(real_agg: dict, sim_agg: dict,
     results["eligible_speed"] = eligible_speed_composition_parity(real_agg, sim_agg)
     results["avail_timebase"] = avail_timebase_parity(real_agg, sim_agg)
     results["duty_cycle"] = duty_cycle_parity(real_trainers, sim_trainers)
+    results["duty_cycle_duration"] = duration_duty_cycle_parity(real_agg, sim_agg)
+    results["eligible_pool_reduction"] = eligible_pool_reduction_parity(
+        real_agg, sim_agg)
+    results["abandon_timeout"] = abandon_timeout_parity(real_agg, sim_agg)
+    results["starvation_advance"] = starvation_advance_parity(real_agg, sim_agg)
+    results["state_timeline_agreement"] = state_timeline_agreement(real_agg, sim_agg)
+    results["trainer_trace_fidelity_real"] = trainer_trace_fidelity_parity(
+        real_trainers, real_agg["selection_train"], "real", real_ground_truth)
+    results["trainer_trace_fidelity_sim"] = trainer_trace_fidelity_parity(
+        sim_trainers, sim_agg["selection_train"], "sim", sim_ground_truth)
+    _a7_real = agg_belief_fidelity_parity(real_agg, "real", real_ground_truth)
+    _a7_sim = agg_belief_fidelity_parity(sim_agg, "sim", sim_ground_truth)
+    results["agg_belief_fidelity_real_selection"] = _a7_real["selection"]
+    results["agg_belief_fidelity_real_commit"] = _a7_real["commit"]
+    results["agg_belief_fidelity_sim_selection"] = _a7_sim["selection"]
+    results["agg_belief_fidelity_sim_commit"] = _a7_sim["commit"]
+    results["send_gate_wait_fidelity_real"] = send_gate_wait_fidelity_parity(
+        real_trainers, real_ground_truth)
 
     # ── Stage 3 Selection ──
     results["selection_detail"] = selection_detail_parity(real_agg, sim_agg)
@@ -2552,6 +3520,8 @@ def run_all_parity(real_agg: dict, sim_agg: dict,
     results["commit_visibility"] = commit_visibility_parity(real_agg, sim_agg)
     results["eval_commit_timeliness"] = eval_commit_timeliness(sim_agg)
     results["staleness"] = staleness_parity(real_agg, sim_agg)
+    results["withheld_delivery"] = withheld_delivery_parity(real_agg, sim_agg)
+    results["commit_promptness"] = commit_promptness_parity(sim_agg)
     results["aggregation_sequence"] = aggregation_sequence_parity(
         real_agg, sim_agg, max_rounds)
 
@@ -2603,6 +3573,18 @@ def run_all_parity(real_agg: dict, sim_agg: dict,
     "eligible_speed":          {"stage": 2, "role": "MECHANISM", "deps": ("eligibility",)},
     "avail_timebase":          {"stage": 2, "role": "CONTROL",  "deps": ("per_round_advance",)},
     "duty_cycle":              {"stage": 2, "role": "MECHANISM", "deps": ("avail_timebase",)},
+    "duty_cycle_duration":     {"stage": 2, "role": "MECHANISM", "deps": ("avail_timebase",)},
+    "eligible_pool_reduction": {"stage": 2, "role": "DIAG",     "deps": ("eligibility",)},
+    "abandon_timeout":         {"stage": 2, "role": "CONTROL",  "deps": ("avail_timebase",)},
+    # A6/A7 (Batch 3 T3.2/T3.3) are absolute (vs. ground truth), not real-vs-sim
+    # — no dependency on avail_timebase (A3), unlike the relative Stage 2 checks above.
+    "trainer_trace_fidelity_real": {"stage": 2, "role": "MECHANISM", "deps": ()},
+    "trainer_trace_fidelity_sim":  {"stage": 2, "role": "MECHANISM", "deps": ()},
+    "agg_belief_fidelity_real_selection": {"stage": 2, "role": "MECHANISM", "deps": ()},
+    "agg_belief_fidelity_real_commit":    {"stage": 2, "role": "MECHANISM", "deps": ()},
+    "agg_belief_fidelity_sim_selection":  {"stage": 2, "role": "MECHANISM", "deps": ()},
+    "agg_belief_fidelity_sim_commit":     {"stage": 2, "role": "MECHANISM", "deps": ()},
+    "send_gate_wait_fidelity_real":       {"stage": 2, "role": "MECHANISM", "deps": ()},
     # ── Stage 3 Selection ──
     "selection_detail":        {"stage": 3, "role": "MECHANISM", "deps": ("eligibility",)},
     "residence":               {"stage": 3, "role": "MECHANISM", "deps": ("eligibility",)},
@@ -2632,6 +3614,8 @@ def run_all_parity(real_agg: dict, sim_agg: dict,
     "commit_visibility":       {"stage": 6, "role": "MECHANISM", "deps": ("per_round_advance",)},
     "eval_commit_timeliness":  {"stage": 6, "role": "MECHANISM", "deps": ("commit_visibility",)},
     "staleness":               {"stage": 6, "role": "MECHANISM", "deps": ("per_round_advance", "inter_arrival_order", "commit_visibility")},
+    "withheld_delivery":       {"stage": 6, "role": "DIAG",     "deps": ("staleness", "abandon_timeout")},
+    "commit_promptness":       {"stage": 6, "role": "CONTROL",  "deps": ("withheld_delivery",)},
     "aggregation_sequence":    {"stage": 6, "role": "EMERGENT", "deps": ("participation", "inter_arrival_order")},
     "first_divergence_summary": {"stage": 6, "role": "DIAG",    "deps": ()},
     # ── Stage 7 Statistical utility ──
@@ -2644,6 +3628,8 @@ def run_all_parity(real_agg: dict, sim_agg: dict,
     # ── Stage 9 Budget / stop sanity (orthogonal) ──
     "budget_not_cap":          {"stage": 9, "role": "DIAG",     "deps": ()},
     "failsafe":                {"stage": 9, "role": "MECHANISM", "deps": ()},
+    # ── Stage F Starvation clock-advance ──
+    "starvation_advance":      {"stage": 2, "role": "DIAG",     "deps": ("abandon_timeout",)},
 }
 
 # Checks whose FAIL is downgraded to WARN regardless of tier (expected-noisy).
diff --git a/lib/python/examples/async_cifar10/scripts/parity/cli.py b/lib/python/examples/async_cifar10/scripts/parity/cli.py
index a069b957c..7a4b2bbc6 100644
--- a/lib/python/examples/async_cifar10/scripts/parity/cli.py
+++ b/lib/python/examples/async_cifar10/scripts/parity/cli.py
@@ -57,6 +57,7 @@ def _run_pair(real_dir: str, sim_dir: str,
     from parity.checks import (
         load_run_dir, run_all_parity, first_divergence,
     )
+    from parity.ground_truth import load_ground_truth, resolve_trace_name
     from parity.report import print_report, write_json, write_plot
 
     real_label = real_label or os.path.basename(real_dir.rstrip("/"))
@@ -67,6 +68,9 @@ def _run_pair(real_dir: str, sim_dir: str,
     print(f"[parity] Loading sim:  {sim_label}")
     sim_agg, sim_trainers = load_run_dir(sim_dir)
 
+    real_ground_truth = load_ground_truth(resolve_trace_name(real_dir))
+    sim_ground_truth = load_ground_truth(resolve_trace_name(sim_dir))
+
     print(f"[parity]   real: {len(real_agg['agg_rounds'])} agg_round events, "
           f"{len(real_agg['selection_train'])} selection events, "
           f"{len(real_agg['agg_evals'])} eval events, "
@@ -81,6 +85,8 @@ def _run_pair(real_dir: str, sim_dir: str,
         agg_goal=agg_goal,
         rounds_cap=rounds_cap,
         budget_s=budget_s,
+        real_ground_truth=real_ground_truth,
+        sim_ground_truth=sim_ground_truth,
     )
 
     # Add first_divergence as a diagnostic summary entry (always ok — index=0 is expected for async)
@@ -120,7 +126,7 @@ def main() -> None:
     parser.add_argument("--rounds-cap", type=int, default=None,
                         help="rounds cap from config (enables K9 truncation check)")
     parser.add_argument("--budget-s", type=float, default=None,
-                        help="max_runtime_s / sim_wall_ceiling_s (enables K5/K9)")
+                        help="max_experiment_runtime_s / sim_wall_ceiling_s (enables K5/K9)")
     parser.add_argument("--strict", action="store_true",
                         help="Treat WARN as FAIL")
     parser.add_argument("--lenient", action="store_true",
diff --git a/lib/python/examples/async_cifar10/scripts/parity/ground_truth.py b/lib/python/examples/async_cifar10/scripts/parity/ground_truth.py
new file mode 100644
index 000000000..d52cc94bd
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/parity/ground_truth.py
@@ -0,0 +1,155 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Ground-truth trace lookups — shared infra for the Batch 3 absolute-fidelity
+rungs (A6 trainer_trace_fidelity, A7 agg_belief_fidelity, A8 send_gate_wait_fidelity).
+
+Deliberately thin (see UNAVAILABILITY_DESIGN.md Batch 3 ▶ Implementation
+phases → Phase 2): reuses flame.availability.trace's load_trace/state_at/
+read_trainer_unavailability almost as-is — no need to reimplement trace
+loading, it already exists in exactly the shape needed. New code here is:
+  (a) a trace-*name* resolver — given a run dir, which of 3 possible config
+      keys holds the trace name actually used (varies by baseline, mirrors
+      debug_run.sh's own 3-way substitution branch), and
+  (b) a duration-weighted, time-range query wrapper around state_at, since the
+      checkers need "fraction of [t_start, t_end] spent in each state", not a
+      single point lookup.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Optional
+
+from sortedcontainers import SortedDict
+
+from flame.availability.trace import (
+    next_avail_after,
+    read_trainer_unavailability,
+    state_at,
+)
+from flame.config import TrainerAvailState
+
+_AVL_STATES = frozenset({TrainerAvailState.AVL_TRAIN, TrainerAvailState.AVL_EVAL})
+
+
+def resolve_trace_name(run_dir: str) -> Optional[str]:
+    """Read aggregator_config.json in run_dir and return the configured trace name.
+
+    Priority mirrors debug_run.sh's own ``--trace`` substitution branch (see
+    UNAVAILABILITY_DESIGN.md Baseline matrix ⁺ note): oort/oort_star/refl write
+    trackTrainerAvail.trace; felix/oort_star (HP-level client_notify path)
+    write client_notify.trace; feddance/fedbuff write availability_trace. Try
+    in that order so a run with more than one key set (e.g. a stale YAML
+    default alongside the live debug_run.sh override) resolves to the one
+    debug_run.sh itself would have picked, not an arbitrary one.
+
+    Returns None if the config file is missing/unreadable or no key is set
+    (gate off / syn_0-style always-available).
+    """
+    path = Path(run_dir) / "aggregator_config.json"
+    try:
+        with open(path, encoding="utf-8") as f:
+            cfg = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return None
+    hp = cfg.get("hyperparameters", cfg)
+
+    track = hp.get("trackTrainerAvail") or {}
+    trace = track.get("trace")
+    if trace:
+        return trace
+
+    client_notify = hp.get("client_notify") or {}
+    trace = client_notify.get("trace")
+    if trace:
+        return trace
+
+    return hp.get("availability_trace") or None
+
+
+def load_ground_truth(
+    trace_name: Optional[str], base_dir: Optional[str] = None
+) -> Optional[dict]:
+    """{task_id: SortedDict[ts -> state_str]} for every registered trainer.
+
+    Thin re-export of flame.availability.trace.read_trainer_unavailability —
+    the canonical per-trainer trace loader, already used aggregator-side.
+    Returns None when trace_name is falsy or the registry/trace can't be read.
+    """
+    return read_trainer_unavailability(trace_name, base_dir=base_dir)
+
+
+def by_short_id(ground_truth: Optional[dict]) -> dict:
+    """Re-key {task_id: trace} to {task_id[-4:]: trace}.
+
+    Matches the short-id convention scripts/parity/checks.py uses for trainer
+    telemetry (load_trainer_jsonl_dir keys on f.stem[-4:]; short() truncates
+    the same way elsewhere in this module) — lets A6/A7 join ground truth
+    directly against per-trainer telemetry dicts without a separate registry
+    lookup at call time.
+    """
+    return {task_id[-4:]: trace for task_id, trace in (ground_truth or {}).items()}
+
+
+def state_fractions_over_range(
+    trace: SortedDict, t_start: float, t_end: float
+) -> dict:
+    """Duration-weighted {state: fraction_of[t_start, t_end]}, read directly
+    off the raw ground-truth trace.
+
+    Exact dwell-time integration over the trace's own transition points
+    within the range (not sampled/binned) — the ground-truth counterpart to
+    avail_state_series.state_fractions(), which does the same integration
+    over an *observed* (telemetry-derived) series instead.
+    """
+    if t_end <= t_start:
+        return {}
+    boundaries = [t_start]
+    boundaries.extend(trace.irange(t_start, t_end, inclusive=(False, False)))
+    boundaries.append(t_end)
+    durations: dict = {}
+    for a, b in zip(boundaries, boundaries[1:]):
+        if b <= a:
+            continue
+        s = state_at(trace, a).value
+        durations[s] = durations.get(s, 0.0) + (b - a)
+    total = sum(durations.values())
+    if total <= 0:
+        return {}
+    return {s: d / total for s, d in durations.items()}
+
+
+def transitions_in_range(trace: SortedDict, t_start: float, t_end: float) -> list:
+    """[(ts, state_str), ...] ground-truth transitions within (t_start, t_end]."""
+    return [
+        (ts, trace[ts]) for ts in trace.irange(t_start, t_end, inclusive=(False, True))
+    ]
+
+
+def expected_send_gate_wait(trace: SortedDict, sct: float) -> Optional[float]:
+    """Ground-truth-expected [SEND_GATE] wait (Batch 3 T3.4, A8): the trainer
+    became ready to send at ``sct`` (its own trace-time-basis clock) -- how
+    long should it have had to wait, per the raw trace, before the gate
+    releases it?
+
+    0 if the trace already shows the trainer AVL_* at ``sct`` (no reason to
+    wait), else the gap to the next AVL_* transition. Same state-check-first
+    logic as ``ClientAvailability.compute_delivery_ts`` (client_availability.py,
+    the sim-side send-gate) -- next_avail_after(trace, sct) alone is NOT
+    enough, since it always returns the *next* transition even when the
+    trainer is already available right now -- expressed as a wait DURATION
+    (this - sct) rather than an absolute delivery time.
+
+    Returns None if the trace never recovers after ``sct``
+    (``next_avail_after`` == inf) -- an unanswerable "would wait forever"
+    case; the caller excludes it from scoring instead of treating it as a
+    numeric error.
+    """
+    if state_at(trace, sct) in _AVL_STATES:
+        return 0.0
+    nxt = next_avail_after(trace, sct)
+    if math.isinf(nxt):
+        return None
+    return max(0.0, nxt - sct)
diff --git a/lib/python/examples/async_cifar10/scripts/parity/report.py b/lib/python/examples/async_cifar10/scripts/parity/report.py
index 78cea17b4..5cdd1b824 100644
--- a/lib/python/examples/async_cifar10/scripts/parity/report.py
+++ b/lib/python/examples/async_cifar10/scripts/parity/report.py
@@ -50,6 +50,18 @@
         ("A2b eligible-pool speed composition", "eligible_speed"),
         ("A3  trace time-base consistency",     "avail_timebase"),
         ("A4  per-trainer duty-cycle",          "duty_cycle"),
+        ("A4dur  duration duty-cycle parity",   "duty_cycle_duration"),
+        ("Aa   eligible-pool reduction (diag)", "eligible_pool_reduction"),
+        ("C.3  abandon_timeout (vclock CTRL)",  "abandon_timeout"),
+        ("Fst  starvation_advance (diag)",      "starvation_advance"),
+        ("A5   state_timeline_agreement",         "state_timeline_agreement"),
+        ("A6r  trainer_trace_fidelity (real, abs)", "trainer_trace_fidelity_real"),
+        ("A6s  trainer_trace_fidelity (sim, abs)",  "trainer_trace_fidelity_sim"),
+        ("A7r.sel  agg_belief_fidelity (real, selection, abs)", "agg_belief_fidelity_real_selection"),
+        ("A7r.com  agg_belief_fidelity (real, commit, abs)",    "agg_belief_fidelity_real_commit"),
+        ("A7s.sel  agg_belief_fidelity (sim, selection, abs)",  "agg_belief_fidelity_sim_selection"),
+        ("A7s.com  agg_belief_fidelity (sim, commit, abs)",     "agg_belief_fidelity_sim_commit"),
+        ("A8r  send_gate_wait_fidelity (real, abs)", "send_gate_wait_fidelity_real"),
     ]),
     ("3", "Selection", [
         ("S3/4 num_chosen / in_flight / eff_c", "selection_detail"),
@@ -82,6 +94,8 @@
     ("6", "Aggregation", [
         ("U6  commit visibility lag",           "commit_visibility"),
         ("U3  staleness distribution",          "staleness"),
+        ("C.2  withheld_delivery (diag)",       "withheld_delivery"),
+        ("K11  commit_promptness (sim, INV)",   "commit_promptness"),
         ("P1  aggregation sequence",            "aggregation_sequence"),
         ("U1  first divergence",                "first_divergence_summary"),
     ]),
@@ -413,6 +427,92 @@ def _fmt_metric(name: str, res: dict) -> list:
                 f"         max_dutycycle_diff={res.get('max_dutycycle_diff')}  "
                 f"n_trainers={res.get('n_trainers')}"
             )
+    elif name == "duty_cycle_duration":
+        if res.get("mean_err") is not None:
+            lines.append(
+                f"         mean_err={res.get('mean_err')} (<={res.get('mean_tol')})  "
+                f"frac_within_tol={res.get('frac_within_tol')} (>={res.get('frac_pass_tol')} "
+                f"@ tau={res.get('within_tau')})  n_trainers={res.get('n_trainers')}"
+            )
+    elif name == "eligible_pool_reduction":
+        if res.get("real_mean_reduction") is not None:
+            lines.append(
+                f"         real_mean_reduction={res.get('real_mean_reduction')}  "
+                f"sim_mean_reduction={res.get('sim_mean_reduction')}  "
+                f"rel_diff={res.get('rel_diff')} (<={res.get('tol_rel')})"
+            )
+    elif name == "state_timeline_agreement":
+        if res.get("match_frac") is not None:
+            lines.append(
+                f"         match_frac={res.get('match_frac')} (>={res.get('tol')})  "
+                f"matched={res.get('matched')}/{res.get('total')} bins  "
+                f"n_trainers={res.get('n_trainers')}  n_bins={res.get('n_bins')}"
+            )
+            if res.get("mismatched_examples"):
+                lines.append(f"         mismatch_examples={res.get('mismatched_examples')}")
+    elif name in ("trainer_trace_fidelity_real", "trainer_trace_fidelity_sim",
+                 "agg_belief_fidelity_real_selection", "agg_belief_fidelity_real_commit",
+                 "agg_belief_fidelity_sim_selection", "agg_belief_fidelity_sim_commit"):
+        if res.get("mean_err") is not None:
+            lines.append(
+                f"         mean_err={res.get('mean_err')} (<={res.get('mean_tol')})  "
+                f"frac_within_tol={res.get('frac_within_tol')} (>={res.get('frac_pass_tol')} "
+                f"@ tau={res.get('within_tau')})  n_trainers={res.get('n_trainers')}"
+            )
+            lines.append(
+                f"         n_missed_transitions={res.get('n_missed_transitions')}  "
+                f"n_spurious_transitions={res.get('n_spurious_transitions')}  "
+                f"max_lag_s={res.get('max_lag_s')}"
+            )
+            if res.get("worst_trainers"):
+                lines.append(f"         worst_trainers={res.get('worst_trainers')}")
+    elif name == "send_gate_wait_fidelity_real":
+        if res.get("mean_err_s") is not None:
+            lines.append(
+                f"         mean_err_s={res.get('mean_err_s')} (<={res.get('mean_tol_s')})  "
+                f"frac_within_tol={res.get('frac_within_tol')} (>={res.get('frac_pass_tol')} "
+                f"@ tau={res.get('within_tau_s')}s)  n_scored={res.get('n_scored')}/"
+                f"{res.get('n_events')}  n_uncomparable={res.get('n_uncomparable')}"
+            )
+    elif name == "abandon_timeout":
+        if res.get("n_abandon") is not None:
+            parts = [f"         n_abandon={res.get('n_abandon')}"]
+            if res.get("mean_age_s") is not None:
+                parts.append(f"mean_age_s={res.get('mean_age_s')}")
+            if res.get("n_aware_boundary_eviction") is not None:
+                parts.append(
+                    f"aware_evictions={res.get('n_aware_boundary_eviction')} "
+                    f"(mean_age={res.get('aware_boundary_eviction_mean_age_s')}s)"
+                )
+            lines.append("  ".join(parts))
+    elif name == "withheld_delivery":
+        if res.get("n_withheld") is not None:
+            lines.append(
+                f"         n_withheld={res.get('n_withheld')}  "
+                f"mean_delay_s={res.get('mean_delay_s')}  "
+                f"mean_staleness={res.get('mean_staleness')}  "
+                f"accept_frac={res.get('accept_frac')}"
+            )
+            if res.get("violations"):
+                lines.append(f"         violations={res.get('violations')}")
+    elif name == "commit_promptness":
+        if res.get("n_events") is not None:
+            lines.append(
+                f"         n_events={res.get('n_events')}  "
+                f"mean_slack_s={res.get('mean_slack_s')}  "
+                f"max_slack_s={res.get('max_slack_s')}  "
+                f"min_slack_s={res.get('min_slack_s')}"
+            )
+            lines.append(
+                f"         n_early_violations={res.get('n_early_violations')} "
+                f"(<={res.get('early_tol_s')}s)  "
+                f"n_late_violations={res.get('n_late_violations')} "
+                f"(<={res.get('late_slack_tol_s')}s)"
+            )
+            if res.get("early_violations"):
+                lines.append(f"         early_violations={res.get('early_violations')}")
+            if res.get("late_violations"):
+                lines.append(f"         late_violations={res.get('late_violations')}")
     elif name == "training_budget":
         if res.get("ks_stat") is not None:
             defer = "  [mix-deferred to A2c]" if res.get("mix_deferred") else ""
diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_agg_belief_fidelity.py b/lib/python/examples/async_cifar10/scripts/parity/test_agg_belief_fidelity.py
new file mode 100644
index 000000000..67f9d5e1c
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/parity/test_agg_belief_fidelity.py
@@ -0,0 +1,209 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.3 — A7 agg_belief_fidelity_parity.
+
+Same synthetic-drift unit-test pattern as T3.2's test_ground_truth.py, applied
+to the aggregator's BELIEF (not the trainer's own avail_change self-report).
+Two independent checkpoints (selection / commit) are tested separately since
+that's the whole point of tagging them apart -- an unaware baseline (oort/
+fedbuff) only ever gets a meaningful commit-checkpoint score.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from sortedcontainers import SortedDict
+
+_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _SCRIPTS not in sys.path:
+    sys.path.insert(0, _SCRIPTS)
+
+from parity.checks import agg_belief_fidelity_parity  # noqa: E402
+
+
+def _sel(round_num, vclock_now, per_trainer):
+    return {"event": "selection", "task": "train", "round": round_num,
+            "ts": vclock_now, "vclock_now": vclock_now, "per_trainer": per_trainer}
+
+
+def _belief(round_num, end_id, state, observed_at, checkpoint="commit"):
+    return {"event": "agg_belief_change", "round": round_num, "end_id": end_id,
+            "state": state, "observed_at": observed_at, "checkpoint": checkpoint}
+
+
+def test_a7_skips_without_ground_truth():
+    agg = {"selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})],
+           "agg_belief_changes": []}
+    res = agg_belief_fidelity_parity(agg, "sim", None)
+    assert res["selection"]["ok"] and res["selection"].get("status") == "SKIP"
+    assert res["commit"]["ok"] and res["commit"].get("status") == "SKIP"
+
+
+def test_a7_skips_on_degenerate_span():
+    agg = {"selection_train": [], "agg_belief_changes": []}
+    gt = {"t1_0001": SortedDict()}
+    res = agg_belief_fidelity_parity(agg, "sim", gt)
+    assert res["selection"].get("status") == "SKIP"
+    assert res["commit"].get("status") == "SKIP"
+
+
+def test_a7_selection_checkpoint_passes_when_matched():
+    # Ground truth: AVL_TRAIN [0,600), UN_AVL [600,900). Aggregator's own
+    # selection-time belief (per_trainer.avl_state) tracks it exactly.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    agg = {
+        "selection_train": [
+            _sel(1, 0.0, {"0001": {"avl_state": "AVL_TRAIN"}}),
+            _sel(2, 600.0, {"0001": {"avl_state": "UN_AVL"}}),
+            _sel(3, 900.0, {"0001": {"avl_state": "UN_AVL"}}),
+        ],
+        "agg_belief_changes": [],
+    }
+    res = agg_belief_fidelity_parity(agg, "sim", gt)
+    assert res["selection"]["ok"], res["selection"]
+    assert res["selection"]["mean_err"] == 0.0
+    # No commit-checkpoint telemetry at all in this run -> SKIP, not a false pass.
+    assert res["commit"].get("status") == "SKIP"
+
+
+def test_a7_selection_checkpoint_fails_when_diverged():
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    agg = {
+        "selection_train": [
+            _sel(1, 0.0, {"0001": {"avl_state": "AVL_TRAIN"}}),
+            _sel(2, 900.0, {"0001": {"avl_state": "AVL_TRAIN"}}),  # never saw UN_AVL
+        ],
+        "agg_belief_changes": [],
+    }
+    res = agg_belief_fidelity_parity(agg, "sim", gt)
+    assert not res["selection"]["ok"], res["selection"]
+    assert res["selection"]["mean_err"] > 0.0
+
+
+def test_a7_commit_checkpoint_passes_when_matched():
+    # Aggregator's own commit-time belief (agg_belief_change, from
+    # _record_commit_belief) reads the same state ground truth has at that
+    # instant -- meaningful even for an unaware baseline with no selection
+    # filter at all (selection_train carries no per_trainer avl_state here).
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    agg = {
+        "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})],
+        "agg_belief_changes": [
+            _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"),
+            _belief(2, "0001", "UN_AVL", 600.0, checkpoint="commit"),
+        ],
+    }
+    res = agg_belief_fidelity_parity(agg, "sim", gt)
+    assert res["commit"]["ok"], res["commit"]
+    assert res["commit"]["mean_err"] == 0.0
+    # No per_trainer.avl_state anywhere -> selection checkpoint has no signal.
+    assert res["selection"].get("status") == "SKIP"
+
+
+def test_a7_commit_checkpoint_fails_on_belief_wrong_at_its_own_instant():
+    # Ground truth transitions at 600s; the aggregator's LAST commit lands at
+    # 900 but still claims AVL_TRAIN -- i.e. a belief-recording bug where the
+    # recorded state doesn't even match ground truth AT its own claimed
+    # instant (unlike the interior-gap case below, where both endpoints are
+    # individually correct and only the un-observed middle differs). This
+    # must still fail post-interior-gap-fix: `max_gap_s` only excuses
+    # UN-observed periods, not a wrong reading at an observed one.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    agg = {
+        "selection_train": [_sel(1, 0.0, {}), _sel(2, 1000.0, {})],
+        "agg_belief_changes": [
+            _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"),
+            _belief(2, "0001", "AVL_TRAIN", 900.0, checkpoint="commit"),  # still wrong
+        ],
+    }
+    res = agg_belief_fidelity_parity(agg, "sim", gt, lag_tol_s=30.0)
+    assert not res["commit"]["ok"], res["commit"]
+    assert res["commit"]["mean_err"] > 0.05
+
+
+def test_a7_commit_checkpoint_ignores_selection_events():
+    # A selection-checkpoint agg_belief_change (if one were ever emitted)
+    # must not leak into the commit-checkpoint score.
+    gt = {"t1_0001": SortedDict()}
+    agg = {
+        "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})],
+        "agg_belief_changes": [
+            _belief(1, "0001", "UN_AVL", 100.0, checkpoint="selection"),
+        ],
+    }
+    res = agg_belief_fidelity_parity(agg, "sim", gt)
+    assert res["commit"].get("status") == "SKIP"
+
+
+def test_a7_commit_checkpoint_does_not_extrapolate_past_last_commit():
+    # Batch 4 finding (UNAVAILABILITY_DESIGN.md): the trainer's last commit
+    # lands at 550 while still AVL_TRAIN (correctly so -- ground truth is
+    # AVL_TRAIN up to 600), then it goes UN_AVL at 600 and never commits
+    # again for the rest of the 900s span. Extrapolating "still AVL_TRAIN"
+    # across [550, 900) would blame ~300/900 of the span on a belief that
+    # was simply never re-sampled, not wrong -- the window must truncate to
+    # [t_start, last observed t] instead.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    agg = {
+        "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})],
+        "agg_belief_changes": [
+            _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"),
+            _belief(2, "0001", "AVL_TRAIN", 550.0, checkpoint="commit"),
+        ],
+    }
+    res = agg_belief_fidelity_parity(agg, "sim", gt)
+    assert res["commit"]["ok"], res["commit"]
+    assert res["commit"]["mean_err"] == 0.0
+    # The untruncated window would have counted the 600s ground-truth
+    # transition as "missed" too (it falls after the last observation) --
+    # truncation excludes it from the diagnostic count as well.
+    assert res["commit"]["n_missed_transitions"] == 0
+
+
+
+def test_a7_commit_checkpoint_does_not_extrapolate_across_interior_gap():
+    # Batch 4 live-run finding (UNAVAILABILITY_DESIGN.md, felix n=300 syn_50):
+    # both commits are individually CORRECT -- t=100 reads AVL_TRAIN (true,
+    # ground truth is AVL_TRAIN on [0,200)), t=590 reads AVL_TRAIN (true,
+    # ground truth is AVL_TRAIN on [400,600)) -- but the trace dips to UN_AVL
+    # on [200,400) in between, with no commit to observe it. Holding the
+    # first commit's belief all the way to the second (old behavior) would
+    # blame ~200/490s of that gap on "wrong belief", when neither commit was
+    # ever wrong at its own instant -- same class of over-penalization the
+    # tail fix (extrapolate_tail=False) already exempts, just mid-run instead
+    # of at the end.
+    gt = {"t1_0001": SortedDict({200.0: "UN_AVL", 400.0: "AVL_TRAIN"})}
+    agg = {
+        "selection_train": [_sel(1, 0.0, {}), _sel(2, 600.0, {})],
+        "agg_belief_changes": [
+            _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"),
+            _belief(2, "0001", "AVL_TRAIN", 590.0, checkpoint="commit"),
+        ],
+    }
+    res = agg_belief_fidelity_parity(agg, "sim", gt, lag_tol_s=30.0)
+    assert res["commit"]["ok"], res["commit"]
+    assert res["commit"]["mean_err"] == 0.0
+
+
+def test_a7_real_and_sim_scored_independently():
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    real_agg = {
+        "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})],
+        "agg_belief_changes": [
+            _belief(1, "0001", "AVL_TRAIN", 100.0),
+            _belief(2, "0001", "AVL_TRAIN", 700.0),  # real never saw UN_AVL
+        ],
+    }
+    sim_agg = {
+        "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})],
+        "agg_belief_changes": [
+            _belief(1, "0001", "AVL_TRAIN", 100.0),
+            _belief(2, "0001", "UN_AVL", 600.0),
+        ],
+    }
+    real_res = agg_belief_fidelity_parity(real_agg, "real", gt)
+    sim_res = agg_belief_fidelity_parity(sim_agg, "sim", gt)
+    assert not real_res["commit"]["ok"]
+    assert sim_res["commit"]["ok"]
diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_avail_state_series.py b/lib/python/examples/async_cifar10/scripts/parity/test_avail_state_series.py
new file mode 100644
index 000000000..0f5917347
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/parity/test_avail_state_series.py
@@ -0,0 +1,119 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Unit tests for the C.6.2 shared trainer_state_series resolver."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _SCRIPTS not in sys.path:
+    sys.path.insert(0, _SCRIPTS)
+
+from parity.avail_state_series import (  # noqa: E402
+    build_trainer_state_series,
+    run_span,
+    state_fractions,
+    total_variation_distance,
+)
+
+
+def _sel(round_num, ts, vclock_now, per_trainer):
+    return {
+        "event": "selection", "task": "train", "round": round_num, "ts": ts,
+        "vclock_now": vclock_now, "per_trainer": per_trainer,
+    }
+
+
+def test_build_series_sim_uses_vclock():
+    events = [
+        _sel(1, 100.0, 0.0, {"t1": {"avl_state": "AVL_TRAIN"}}),
+        _sel(2, 110.0, 600.0, {"t1": {"avl_state": "UN_AVL"}}),
+        _sel(3, 120.0, 900.0, {"t1": {"avl_state": "AVL_TRAIN"}}),
+    ]
+    series = build_trainer_state_series(events, mode="sim")
+    assert series["t1"] == [
+        (0.0, "AVL_TRAIN"), (600.0, "UN_AVL"), (900.0, "AVL_TRAIN"),
+    ]
+
+
+def test_build_series_real_uses_ts_minus_t0():
+    events = [
+        _sel(1, 1000.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}),
+        _sel(2, 1300.0, None, {"t1": {"avl_state": "UN_AVL"}}),
+    ]
+    series = build_trainer_state_series(events, mode="real")
+    assert series["t1"] == [(0.0, "AVL_TRAIN"), (300.0, "UN_AVL")]
+
+
+def test_build_series_real_prefers_vclock_now_over_ts_minus_t0():
+    # Real-mode first selection event fires well after the true run start
+    # (e.g. ~300s of MQTT join-ramp for n=300) — ts - t0 would understate
+    # elapsed time relative to the trace's agg_start-anchored origin. Once
+    # vclock_now is stamped on real events too (ClientAvailability._avail_now()),
+    # it must win over the ts - t0 fallback.
+    events = [
+        _sel(1, 1000.0, 600.0, {"t1": {"avl_state": "AVL_TRAIN"}}),
+        _sel(2, 1300.0, 900.0, {"t1": {"avl_state": "UN_AVL"}}),
+    ]
+    series = build_trainer_state_series(events, mode="real")
+    assert series["t1"] == [(600.0, "AVL_TRAIN"), (900.0, "UN_AVL")]
+
+
+def test_build_series_skips_unknown_state():
+    events = [_sel(1, 0.0, 0.0, {"t1": {"avl_state": "UNKNOWN"}})]
+    series = build_trainer_state_series(events, mode="sim")
+    assert series == {}
+
+
+def test_build_series_same_t_last_write_wins():
+    events = [
+        _sel(1, 0.0, 100.0, {"t1": {"avl_state": "AVL_TRAIN"}}),
+        _sel(2, 0.0, 100.0, {"t1": {"avl_state": "UN_AVL"}}),
+    ]
+    series = build_trainer_state_series(events, mode="sim")
+    assert series["t1"] == [(100.0, "UN_AVL")]
+
+
+def test_run_span():
+    series = {"t1": [(0.0, "AVL_TRAIN"), (900.0, "UN_AVL")],
+              "t2": [(0.0, "AVL_TRAIN"), (500.0, "UN_AVL")]}
+    assert run_span(series) == 900.0
+
+
+def test_state_fractions_dwell_time():
+    # AVL_TRAIN for 600s, then UN_AVL for the remaining 300s of a 900s span.
+    series = {"t1": [(0.0, "AVL_TRAIN"), (600.0, "UN_AVL"), (900.0, "UN_AVL")]}
+    fracs = state_fractions(series)
+    assert fracs["t1"]["AVL_TRAIN"] == 600.0 / 900.0
+    assert fracs["t1"]["UN_AVL"] == 300.0 / 900.0
+
+
+def test_state_fractions_credits_trailing_segment_to_t_end():
+    series = {"t1": [(0.0, "AVL_TRAIN"), (600.0, "UN_AVL")]}
+    fracs = state_fractions(series, t_end=900.0)
+    assert fracs["t1"]["AVL_TRAIN"] == 600.0 / 900.0
+    assert fracs["t1"]["UN_AVL"] == 300.0 / 900.0
+
+
+def test_state_fractions_omits_single_sample_trainers():
+    series = {"t1": [(0.0, "AVL_TRAIN")]}
+    assert state_fractions(series) == {}
+
+
+def test_total_variation_distance_identical_is_zero():
+    a = {"AVL_TRAIN": 0.7, "UN_AVL": 0.3}
+    assert total_variation_distance(a, dict(a)) == 0.0
+
+
+def test_total_variation_distance_disjoint_is_one():
+    a = {"AVL_TRAIN": 1.0}
+    b = {"UN_AVL": 1.0}
+    assert total_variation_distance(a, b) == 1.0
+
+
+def test_total_variation_distance_partial():
+    a = {"AVL_TRAIN": 0.6, "UN_AVL": 0.4}
+    b = {"AVL_TRAIN": 0.5, "UN_AVL": 0.5}
+    assert abs(total_variation_distance(a, b) - 0.1) < 1e-9
diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_availability_rungs.py b/lib/python/examples/async_cifar10/scripts/parity/test_availability_rungs.py
new file mode 100644
index 000000000..0a84ef2db
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/parity/test_availability_rungs.py
@@ -0,0 +1,334 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Stage C parity rungs: withheld_delivery / abandon_timeout / eligible_pool_reduction.
+
+These cover the run-independent (structural) logic of the new availability rungs
+and the loader fields that feed them. Tolerance calibration vs a real syn_20
+reference is deferred to an actual run (these only assert what is true regardless
+of run data: ordering invariants, the vclock wall-leak guard, and SKIP/empty
+handling).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _SCRIPTS not in sys.path:
+    sys.path.insert(0, _SCRIPTS)
+
+from parity.checks import (  # noqa: E402
+    abandon_timeout_parity,
+    commit_promptness_parity,
+    duration_duty_cycle_parity,
+    eligible_pool_reduction_parity,
+    load_agg_jsonl,
+    load_trainer_jsonl_dir,
+    starvation_advance_parity,
+    withheld_delivery_parity,
+)
+
+
+def _sel(round_num, nc, ne):
+    return {"event": "selection", "task": "train", "round": round_num,
+            "ts": float(round_num), "num_candidates": nc, "num_eligible": ne}
+
+
+# ---------------------------------------------------------------------------
+# withheld_delivery
+# ---------------------------------------------------------------------------
+
+def test_withheld_delivery_skips_when_empty():
+    res = withheld_delivery_parity({}, {"withheld_deliveries": []})
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_withheld_delivery_passes_well_formed():
+    evs = [
+        {"end_id": "t1", "sct": 150.0, "delivery_ts": 200.0, "delay_s": 50.0,
+         "staleness": 3, "accepted": True},
+        {"end_id": "t2", "sct": 260.0, "delivery_ts": 260.0, "delay_s": 0.0,
+         "staleness": 0, "accepted": True},
+    ]
+    res = withheld_delivery_parity({}, {"withheld_deliveries": evs})
+    assert res["ok"], res
+    assert res["n_withheld"] == 2
+    assert res["accept_frac"] == 1.0
+    assert res["mean_delay_s"] == 25.0
+
+
+def test_withheld_delivery_fails_on_pre_completion_delivery():
+    # delivery_ts < sct would be past-dating — must fail loudly.
+    evs = [{"end_id": "t1", "sct": 200.0, "delivery_ts": 150.0, "staleness": 1}]
+    res = withheld_delivery_parity({}, {"withheld_deliveries": evs})
+    assert not res["ok"] and res["violations"]
+
+
+def test_withheld_delivery_fails_on_negative_staleness():
+    evs = [{"end_id": "t1", "sct": 100.0, "delivery_ts": 120.0, "staleness": -2}]
+    res = withheld_delivery_parity({}, {"withheld_deliveries": evs})
+    assert not res["ok"]
+
+
+# ---------------------------------------------------------------------------
+# commit_promptness (K11, Batch 3 T3.5)
+# ---------------------------------------------------------------------------
+
+def test_commit_promptness_skips_when_empty():
+    res = commit_promptness_parity({"withheld_deliveries": []})
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_commit_promptness_skips_when_no_actual_commit_ts():
+    # Telemetry predating T3.5: delivery_ts present, actual_commit_ts absent.
+    evs = [{"end_id": "t1", "sct": 100.0, "delivery_ts": 150.0}]
+    res = commit_promptness_parity({"withheld_deliveries": evs})
+    assert res.get("status") == "SKIP"
+
+
+def test_commit_promptness_passes_near_zero_slack():
+    evs = [
+        {"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 200.0},
+        {"end_id": "t2", "delivery_ts": 300.0, "actual_commit_ts": 300.4},
+    ]
+    res = commit_promptness_parity({"withheld_deliveries": evs})
+    assert res["ok"], res
+    assert res["n_events"] == 2
+    assert res["n_early_violations"] == 0
+    assert res["n_late_violations"] == 0
+
+
+def test_commit_promptness_fails_on_early_violation():
+    # Committed BEFORE its legal delivery_ts -- a hard correctness bug.
+    evs = [{"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 150.0}]
+    res = commit_promptness_parity({"withheld_deliveries": evs})
+    assert not res["ok"], res
+    assert res["n_early_violations"] == 1
+    assert res["early_violations"] == [{"end": "t1", "slack_s": -50.0}]
+    assert res["n_late_violations"] == 0
+
+
+def test_commit_promptness_fails_on_late_violation():
+    # Held far longer than delivery_ts required -- a promptness/scheduling bug.
+    evs = [{"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 260.0}]
+    res = commit_promptness_parity({"withheld_deliveries": evs}, late_slack_tol_s=30.0)
+    assert not res["ok"], res
+    assert res["n_late_violations"] == 1
+    assert res["late_violations"] == [{"end": "t1", "slack_s": 60.0}]
+    assert res["n_early_violations"] == 0
+
+
+def test_commit_promptness_early_and_late_scored_independently():
+    evs = [
+        {"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 150.0},  # early
+        {"end_id": "t2", "delivery_ts": 200.0, "actual_commit_ts": 260.0},  # late
+        {"end_id": "t3", "delivery_ts": 200.0, "actual_commit_ts": 200.5},  # fine
+    ]
+    res = commit_promptness_parity({"withheld_deliveries": evs}, late_slack_tol_s=30.0)
+    assert not res["ok"]
+    assert res["n_events"] == 3
+    assert res["n_early_violations"] == 1
+    assert res["n_late_violations"] == 1
+
+
+def test_commit_promptness_ignores_events_missing_delivery_ts():
+    evs = [{"end_id": "t1", "actual_commit_ts": 200.0}]
+    res = commit_promptness_parity({"withheld_deliveries": evs})
+    assert res.get("status") == "SKIP"
+
+
+# ---------------------------------------------------------------------------
+# abandon_timeout  (vclock wall-leak control)
+# ---------------------------------------------------------------------------
+
+def test_abandon_skips_when_empty():
+    res = abandon_timeout_parity({}, {"abandon_timeouts": []})
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_abandon_passes_vclock_scale_ages():
+    evs = [{"end_id": "t1", "sim_send_ts": 100.0, "vclock_now": 195.0, "age_s": 95.0},
+           {"end_id": "t2", "sim_send_ts": 50.0, "vclock_now": 200.0, "age_s": 150.0}]
+    res = abandon_timeout_parity({}, {"abandon_timeouts": evs})
+    assert res["ok"], res
+    assert res["n_abandon"] == 2 and res["mean_age_s"] >= 90
+
+
+def test_abandon_fails_on_wall_clock_leak():
+    # epoch-scale age => the deadline was measured on the wall, not the vclock.
+    evs = [{"end_id": "t1", "sim_send_ts": 0.0, "vclock_now": 1.75e9, "age_s": 1.75e9}]
+    res = abandon_timeout_parity({}, {"abandon_timeouts": evs})
+    assert not res["ok"] and res["wall_leak_ends"] == ["t1"]
+    assert "WALL-CLOCK LEAK" in res.get("note", "")
+
+
+def test_abandon_fails_below_threshold():
+    evs = [{"end_id": "t1", "sim_send_ts": 100.0, "vclock_now": 150.0, "age_s": 50.0}]
+    res = abandon_timeout_parity({}, {"abandon_timeouts": evs})
+    assert not res["ok"] and res["below_threshold"]
+
+
+def test_abandon_age_derived_when_missing():
+    evs = [{"end_id": "t1", "sim_send_ts": 100.0, "vclock_now": 195.0}]  # no age_s
+    res = abandon_timeout_parity({}, {"abandon_timeouts": evs})
+    assert res["ok"] and res["max_age_s"] == 95.0
+
+
+# ---------------------------------------------------------------------------
+# eligible_pool_reduction
+# ---------------------------------------------------------------------------
+
+def test_eligible_pool_reduction_skips_without_fields():
+    real = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0}]}
+    sim = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0}]}
+    res = eligible_pool_reduction_parity(real, sim)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_eligible_pool_reduction_passes_when_matched():
+    real = {"selection_train": [_sel(1, 300, 240), _sel(2, 300, 250)]}  # red 60,50
+    sim = {"selection_train": [_sel(1, 300, 245), _sel(2, 300, 248)]}   # red 55,52
+    res = eligible_pool_reduction_parity(real, sim)
+    assert res["ok"], res
+
+
+def test_eligible_pool_reduction_fails_when_divergent():
+    real = {"selection_train": [_sel(1, 300, 290), _sel(2, 300, 292)]}  # red ~9
+    sim = {"selection_train": [_sel(1, 300, 200), _sel(2, 300, 210)]}   # red ~95
+    res = eligible_pool_reduction_parity(real, sim)
+    assert not res["ok"]
+
+
+# ---------------------------------------------------------------------------
+# duty_cycle_duration (A4dur, C.6.3)
+# ---------------------------------------------------------------------------
+
+def _sel_avl(round_num, ts, vclock_now, per_trainer):
+    return {"event": "selection", "task": "train", "round": round_num, "ts": ts,
+            "vclock_now": vclock_now, "per_trainer": per_trainer}
+
+
+def test_duty_cycle_duration_skips_without_avl_state():
+    real = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0,
+                                  "per_trainer": {"t1": {}}}]}
+    sim = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0,
+                                 "vclock_now": 0.0, "per_trainer": {"t1": {}}}]}
+    res = duration_duty_cycle_parity(real, sim)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_duty_cycle_duration_passes_when_matched():
+    # t1: AVL_TRAIN for [0,600), UN_AVL for [600,900) in both modes.
+    real = {"selection_train": [
+        _sel_avl(1, 1000.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}),
+        _sel_avl(2, 1600.0, None, {"t1": {"avl_state": "UN_AVL"}}),
+        _sel_avl(3, 1900.0, None, {"t1": {"avl_state": "UN_AVL"}}),
+    ]}
+    sim = {"selection_train": [
+        _sel_avl(1, 0.0, 0.0, {"t1": {"avl_state": "AVL_TRAIN"}}),
+        _sel_avl(2, 0.0, 600.0, {"t1": {"avl_state": "UN_AVL"}}),
+        _sel_avl(3, 0.0, 900.0, {"t1": {"avl_state": "UN_AVL"}}),
+    ]}
+    res = duration_duty_cycle_parity(real, sim)
+    assert res["ok"], res
+    assert res["n_trainers"] == 1
+    assert res["mean_err"] == 0.0
+
+
+def test_duty_cycle_duration_fails_when_divergent():
+    # real: AVL_TRAIN the whole span. sim: UN_AVL the whole span -> TVD = 1.0.
+    real = {"selection_train": [
+        _sel_avl(1, 1000.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}),
+        _sel_avl(2, 1900.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}),
+    ]}
+    sim = {"selection_train": [
+        _sel_avl(1, 0.0, 0.0, {"t1": {"avl_state": "UN_AVL"}}),
+        _sel_avl(2, 0.0, 900.0, {"t1": {"avl_state": "UN_AVL"}}),
+    ]}
+    res = duration_duty_cycle_parity(real, sim)
+    assert not res["ok"]
+    assert res["mean_err"] == 1.0
+
+
+# ---------------------------------------------------------------------------
+# loaders surface the new events
+# ---------------------------------------------------------------------------
+
+def test_load_agg_jsonl_surfaces_new_events(tmp_path):
+    p = tmp_path / "aggregator_x.jsonl"
+    lines = [
+        {"event": "selection", "task": "train", "round": 1, "ts": 1.0,
+         "num_candidates": 300, "num_eligible": 250},
+        {"event": "withheld_delivery", "round": 2, "ts": 2.0, "end_id": "t1",
+         "sct": 10.0, "delivery_ts": 20.0, "delay_s": 10.0, "staleness": 1},
+        {"event": "abandon_timeout", "round": 3, "ts": 3.0, "end_id": "t2",
+         "sim_send_ts": 5.0, "vclock_now": 100.0, "age_s": 95.0},
+    ]
+    p.write_text("\n".join(json.dumps(x) for x in lines) + "\n")
+    agg = load_agg_jsonl(str(p))
+    assert len(agg["withheld_deliveries"]) == 1
+    assert len(agg["abandon_timeouts"]) == 1
+    assert agg["withheld_deliveries"][0]["end_id"] == "t1"
+
+
+# ---------------------------------------------------------------------------
+# starvation_advance
+# ---------------------------------------------------------------------------
+
+def _agg_round(vclock_now):
+    return {"event": "agg_round", "vclock_now": vclock_now}
+
+
+def _sim_with_avail(rounds, withheld=True):
+    """Build a sim dict with gate-active marker and given agg_round list."""
+    return {
+        "agg_rounds": rounds,
+        "withheld_deliveries": [{"end_id": "t0"}] if withheld else [],
+        "abandon_timeouts": [],
+        "selection_train": [],
+    }
+
+
+def test_starvation_advance_skips_without_avail():
+    # no withheld/abandon/avail_composition → gate off → SKIP
+    sim = {"agg_rounds": [_agg_round(10.0), _agg_round(20.0), _agg_round(30.0)],
+           "withheld_deliveries": [], "abandon_timeouts": [], "selection_train": []}
+    res = starvation_advance_parity({}, sim)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_starvation_advance_skips_with_no_agg_rounds():
+    sim = _sim_with_avail([])
+    res = starvation_advance_parity({}, sim)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_starvation_advance_no_jumps():
+    sim = _sim_with_avail([_agg_round(float(i * 100)) for i in range(10)])
+    res = starvation_advance_parity({}, sim)
+    assert res["ok"] and res["n_starvation_jumps"] == 0
+
+
+def test_starvation_advance_detects_jump():
+    # 8 normal 100s gaps then one 3000s gap (30× mean)
+    vclocks = [float(i * 100) for i in range(8)] + [800.0 + 3000.0]
+    sim = _sim_with_avail([_agg_round(v) for v in vclocks])
+    res = starvation_advance_parity({}, sim, jump_factor=5.0)
+    assert res["ok"] and res["n_starvation_jumps"] >= 1
+    assert res["max_jump_s"] > 1000.0
+
+
+def test_load_trainer_jsonl_dir_surfaces_avail_change(tmp_path):
+    p = tmp_path / "trainer_0001.jsonl"
+    lines = [
+        {"event": "task_recv", "round": 1},
+        {"event": "avail_change", "round": 1, "old_state": "AVL_TRAIN",
+         "new_state": "UN_AVL"},
+    ]
+    p.write_text("\n".join(json.dumps(x) for x in lines) + "\n")
+    tr = load_trainer_jsonl_dir(str(tmp_path))
+    assert "0001" in tr
+    assert len(tr["0001"]["avail_change"]) == 1
+    assert tr["0001"]["avail_change"][0]["new_state"] == "UN_AVL"
diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_ground_truth.py b/lib/python/examples/async_cifar10/scripts/parity/test_ground_truth.py
new file mode 100644
index 000000000..4c51adb9f
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/parity/test_ground_truth.py
@@ -0,0 +1,245 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.2 — ground_truth.py + A6 trainer_trace_fidelity_parity.
+
+Unlike the relative (real-vs-sim) rungs in test_availability_rungs.py, A6
+compares one mode's own trainer telemetry against a synthetic ground-truth
+trace directly — these tests inject a *known* drift between "observed" and
+"ground truth" and assert the fidelity calc measures and flags it correctly,
+per the working agreement (synthetic-drift unit test before touching real data).
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import sys
+
+from sortedcontainers import SortedDict
+
+_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _SCRIPTS not in sys.path:
+    sys.path.insert(0, _SCRIPTS)
+
+from parity.checks import trainer_trace_fidelity_parity  # noqa: E402
+from parity.ground_truth import (  # noqa: E402
+    by_short_id,
+    expected_send_gate_wait,
+    load_ground_truth,
+    resolve_trace_name,
+    state_fractions_over_range,
+    transitions_in_range,
+)
+
+
+def _sel(round_num, vclock_now):
+    return {"event": "selection", "task": "train", "round": round_num,
+            "ts": vclock_now, "vclock_now": vclock_now}
+
+
+def _avail_change(round_num, old_state, new_state, sim_now):
+    return {"event": "avail_change", "round": round_num, "old_state": old_state,
+            "new_state": new_state, "sim_now": sim_now}
+
+
+# ---------------------------------------------------------------------------
+# resolve_trace_name
+# ---------------------------------------------------------------------------
+
+def _write_config(tmp_path, hp: dict):
+    p = tmp_path / "aggregator_config.json"
+    p.write_text(json.dumps({"hyperparameters": hp}))
+    return tmp_path
+
+
+def test_resolve_trace_name_missing_file(tmp_path):
+    assert resolve_trace_name(str(tmp_path)) is None
+
+
+def test_resolve_trace_name_no_keys_set(tmp_path):
+    _write_config(tmp_path, {"trackTrainerAvail": {"enabled": "False", "type": "NA"}})
+    assert resolve_trace_name(str(tmp_path)) is None
+
+
+def test_resolve_trace_name_track_trainer_avail_priority(tmp_path):
+    # All three keys set -> trackTrainerAvail wins (debug_run.sh's own priority).
+    _write_config(tmp_path, {
+        "trackTrainerAvail": {"enabled": "True", "type": "ORACULAR", "trace": "syn_20"},
+        "client_notify": {"enabled": "False", "trace": "syn_50"},
+        "availability_trace": "syn_0",
+    })
+    assert resolve_trace_name(str(tmp_path)) == "syn_20"
+
+
+def test_resolve_trace_name_client_notify_fallback(tmp_path):
+    _write_config(tmp_path, {
+        "trackTrainerAvail": {"enabled": "False", "type": "NA"},
+        "client_notify": {"enabled": "False", "trace": "syn_20"},
+    })
+    assert resolve_trace_name(str(tmp_path)) == "syn_20"
+
+
+def test_resolve_trace_name_availability_trace_fallback(tmp_path):
+    _write_config(tmp_path, {"availability_trace": "syn_50"})
+    assert resolve_trace_name(str(tmp_path)) == "syn_50"
+
+
+def test_load_ground_truth_none_when_no_trace():
+    assert load_ground_truth(None) is None
+
+
+# ---------------------------------------------------------------------------
+# state_fractions_over_range / transitions_in_range
+# ---------------------------------------------------------------------------
+
+def test_state_fractions_over_range_always_available():
+    trace = SortedDict()  # syn_0-style empty trace -> always AVL_TRAIN
+    frac = state_fractions_over_range(trace, 0.0, 100.0)
+    assert frac == {"AVL_TRAIN": 1.0}
+
+
+def test_state_fractions_over_range_single_transition():
+    trace = SortedDict({600.0: "UN_AVL"})
+    frac = state_fractions_over_range(trace, 0.0, 900.0)
+    assert math.isclose(frac["AVL_TRAIN"], 600.0 / 900.0)
+    assert math.isclose(frac["UN_AVL"], 300.0 / 900.0)
+
+
+def test_state_fractions_over_range_degenerate():
+    trace = SortedDict({600.0: "UN_AVL"})
+    assert state_fractions_over_range(trace, 100.0, 100.0) == {}
+
+
+def test_transitions_in_range():
+    trace = SortedDict({100.0: "UN_AVL", 200.0: "AVL_TRAIN", 500.0: "UN_AVL"})
+    assert transitions_in_range(trace, 0.0, 300.0) == [
+        (100.0, "UN_AVL"), (200.0, "AVL_TRAIN"),
+    ]
+    # left-exclusive: a transition exactly at t_start is not "within" the range.
+    assert transitions_in_range(trace, 100.0, 300.0) == [(200.0, "AVL_TRAIN")]
+
+
+def test_by_short_id():
+    gt = {"505f9fc483cf4df68a2409257b5fad7d3c580370": SortedDict()}
+    out = by_short_id(gt)
+    assert list(out) == ["0370"]
+
+
+# ---------------------------------------------------------------------------
+# expected_send_gate_wait (Batch 3 T3.4, A8)
+# ---------------------------------------------------------------------------
+
+def test_expected_send_gate_wait_already_available():
+    trace = SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})
+    # sct before the drop -> already AVL_TRAIN there (default), no wait.
+    assert expected_send_gate_wait(trace, 500.0) == 0.0
+
+
+def test_expected_send_gate_wait_mid_gap():
+    trace = SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})
+    # sct lands inside the UN_AVL window -> wait until the recovery transition.
+    assert math.isclose(expected_send_gate_wait(trace, 700.0), 200.0)
+
+
+def test_expected_send_gate_wait_exact_transition_boundary():
+    trace = SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})
+    # sct exactly at the recovery point -> already available, zero wait.
+    assert expected_send_gate_wait(trace, 900.0) == 0.0
+
+
+def test_expected_send_gate_wait_never_recovers():
+    trace = SortedDict({600.0: "UN_AVL"})
+    assert expected_send_gate_wait(trace, 700.0) is None
+
+
+# ---------------------------------------------------------------------------
+# trainer_trace_fidelity_parity (A6)
+# ---------------------------------------------------------------------------
+
+def test_a6_skips_without_ground_truth():
+    trainers = {"0001": {"avail_change": [_avail_change(1, "AVL_TRAIN", "UN_AVL", 100.0)]}}
+    sel = [_sel(1, 900.0)]
+    res = trainer_trace_fidelity_parity(trainers, sel, "sim", None)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_a6_skips_on_degenerate_span():
+    trainers = {"0001": {"avail_change": []}}
+    gt = {"t1_0001": SortedDict()}
+    res = trainer_trace_fidelity_parity(trainers, [], "sim", gt)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_a6_skips_when_no_matching_trainers():
+    # ground truth keyed by a short id that never shows up in trainer telemetry.
+    trainers = {"0001": {"avail_change": []}}
+    gt = {"t1_9999": SortedDict()}
+    sel = [_sel(1, 900.0)]
+    res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_a6_passes_when_observed_matches_ground_truth():
+    # Ground truth: AVL_TRAIN [0,600), UN_AVL [600,900). Trainer observes and
+    # logs the exact same transition at the exact same trace-time.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    trainers = {"0001": {"avail_change": [
+        _avail_change(1, "AVL_TRAIN", "UN_AVL", 600.0),
+    ]}}
+    sel = [_sel(1, 0.0), _sel(2, 900.0)]
+    res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt)
+    assert res["ok"], res
+    assert res["n_trainers"] == 1
+    assert res["mean_err"] == 0.0
+    assert res["n_missed_transitions"] == 0
+    assert res["n_spurious_transitions"] == 0
+    assert res["max_lag_s"] == 0.0
+
+
+def test_a6_fails_when_trainer_never_tracked_the_trace():
+    # This is exactly Challenges §5 item 20: the trainer's own trace was
+    # wired to a trivial always-available one, so it never logs any
+    # transition, while ground truth says it should have gone UN_AVL at 600s
+    # for the back half of a 900s run -- a full state-fraction mismatch.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    trainers = {"0001": {"avail_change": []}}
+    sel = [_sel(1, 0.0), _sel(2, 900.0)]
+    res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt)
+    # No sim_now-tagged avail_change events anywhere in the run -> SKIP, not a
+    # false "perfect fidelity" pass -- distinguishing "never transitioned" from
+    # "no fidelity signal at all" is the whole point of this rung.
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_a6_fails_on_injected_lag_drift():
+    # Ground truth transitions at 600s; the trainer's own clock is skewed and
+    # only logs the transition (and its corresponding entry into the observed
+    # timeline) 300s late -- same class of bug as B2.0.3, but on the trainer
+    # side. Duration-weighted TVD should catch the resulting fraction skew.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    trainers = {"0001": {"avail_change": [
+        _avail_change(1, "AVL_TRAIN", "UN_AVL", 900.0),  # 300s late
+    ]}}
+    sel = [_sel(1, 0.0), _sel(2, 900.0)]
+    res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt, lag_tol_s=30.0)
+    assert not res["ok"], res
+    assert res["mean_err"] > 0.05
+    assert res["n_missed_transitions"] == 1  # 300s lag exceeds lag_tol_s
+    assert res["n_spurious_transitions"] == 1
+
+
+def test_a6_syn0_regression_perfect_fidelity():
+    # syn_0-style always-available trace: empty ground-truth SortedDict, and a
+    # trainer that (correctly) never transitions -- but DOES carry at least
+    # one sim_now-tagged avail_change event (e.g. a same-state re-stamp),
+    # otherwise there's no fidelity signal to distinguish from "never ran
+    # T3.2's telemetry fix" (see test_a6_fails_when_trainer_never_tracked_the_trace).
+    gt = {"t1_0001": SortedDict()}
+    trainers = {"0001": {"avail_change": [
+        _avail_change(1, "AVL_TRAIN", "AVL_TRAIN", 0.0),
+    ]}}
+    sel = [_sel(1, 0.0), _sel(2, 900.0)]
+    res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt)
+    assert res["ok"], res
+    assert res["mean_err"] == 0.0
diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py b/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py
index 2ff3bb397..c04421659 100644
--- a/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py
+++ b/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py
@@ -214,6 +214,63 @@ def test_avail_timebase_detects_trajectory_shift():
     assert not results["avail_timebase"]["ok"], "A3 should catch the shift"
 
 
+def test_avail_timebase_passes_aligned():
+    """A3 passes when sim eligible-count trajectory matches real within tolerance."""
+    real_agg, real_tr = _build_mode(40, advance=10.0, with_vclock=False)
+    sim_agg, sim_tr = _build_mode(40, advance=10.0, with_vclock=True)
+    # Identical num_eligible (already set to 10 by _build_mode) — must pass.
+    results, _ = _verdict(real_agg, sim_agg, real_tr, sim_tr)
+    assert results["avail_timebase"]["ok"], "aligned trajectory should pass A3"
+
+
+def test_avail_timebase_skips_without_eligible_data():
+    """A3 skips when selection events carry no num_eligible field."""
+    from parity.checks import avail_timebase_parity
+    real_agg = {"selection_train": [{"event": "selection", "round": r} for r in range(1, 21)]}
+    sim_agg = {"selection_train": [{"event": "selection", "round": r} for r in range(1, 21)]}
+    res = avail_timebase_parity(real_agg, sim_agg)
+    assert res.get("status") == "SKIP" or res["ok"], "no num_eligible → A3 must skip or pass"
+
+
+def test_duty_cycle_skips_without_avail_change_telemetry():
+    """A4 skips when no avail_change telemetry is present (default for syn_0 runs)."""
+    from parity.checks import duty_cycle_parity
+    real_tr, sim_tr = {}, {}
+    for tid in TRAINERS:
+        real_tr[tid] = {"task_recv": [], "trainer_round": []}
+        sim_tr[tid] = {"task_recv": [], "trainer_round": []}
+    res = duty_cycle_parity(real_tr, sim_tr)
+    assert res["ok"] and res.get("status") == "SKIP", "no telemetry → A4 must skip"
+
+
+def test_duty_cycle_passes_matched_fractions():
+    """A4 passes when sim and real duty-cycles match.
+
+    avail_change telemetry carries {old_state, new_state} (build_avail_change),
+    so "available" = new_state startswith AVL_*.
+    """
+    from parity.checks import duty_cycle_parity
+    # 3 transitions per trainer: →AVL_TRAIN / →UN_AVL / →AVL_TRAIN → on_frac = 2/3
+    evs = [{"new_state": "AVL_TRAIN"}, {"new_state": "UN_AVL"},
+           {"new_state": "AVL_TRAIN"}]
+    real_tr = {tid: {"avail_change": evs} for tid in TRAINERS}
+    sim_tr = {tid: {"avail_change": evs} for tid in TRAINERS}
+    res = duty_cycle_parity(real_tr, sim_tr)
+    assert res["ok"], f"matched duty-cycles must pass A4: {res}"
+
+
+def test_duty_cycle_fails_mismatch():
+    """A4 fails when sim duty-cycle diverges from real by more than tolerance."""
+    from parity.checks import duty_cycle_parity
+    # Real: mostly available (on_frac=0.8); sim: mostly unavailable (on_frac=0.2).
+    real_evs = [{"new_state": "AVL_TRAIN"}] * 8 + [{"new_state": "UN_AVL"}] * 2
+    sim_evs = [{"new_state": "AVL_TRAIN"}] * 2 + [{"new_state": "UN_AVL"}] * 8
+    real_tr = {tid: {"avail_change": real_evs} for tid in TRAINERS}
+    sim_tr = {tid: {"avail_change": sim_evs} for tid in TRAINERS}
+    res = duty_cycle_parity(real_tr, sim_tr)
+    assert not res["ok"], f"duty-cycle mismatch (0.8 vs 0.2) must fail A4: {res}"
+
+
 def test_eligibility_pointmass_passes_on_mean():
     """A2: real num_eligible is a constant point-mass (300), sim 298.9 ± tiny.
     KS saturates to ~1 but the means match — must PASS on the mean (PARITY.md §3i),
diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_send_gate_wait_fidelity.py b/lib/python/examples/async_cifar10/scripts/parity/test_send_gate_wait_fidelity.py
new file mode 100644
index 000000000..ccc6ff104
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/parity/test_send_gate_wait_fidelity.py
@@ -0,0 +1,108 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.4 — A8 send_gate_wait_fidelity_parity.
+
+Same synthetic-drift unit-test pattern as T3.2/T3.3 (test_ground_truth.py /
+test_agg_belief_fidelity.py), applied to the trainer-side [SEND_GATE] wait
+duration: does the observed send_gate_wait_s match what the raw trace says
+the wait SHOULD have been, given send_gate_sct (the trainer's own
+trace-time-basis clock sampled right before the gate check)?
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from sortedcontainers import SortedDict
+
+_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _SCRIPTS not in sys.path:
+    sys.path.insert(0, _SCRIPTS)
+
+from parity.checks import send_gate_wait_fidelity_parity  # noqa: E402
+
+
+def _task_send(round_num, send_gate_wait_s, send_gate_sct):
+    return {
+        "event": "task_send", "round": round_num, "task_to_perform": "train",
+        "send_gate_wait_s": send_gate_wait_s, "send_gate_sct": send_gate_sct,
+    }
+
+
+def test_a8_skips_without_ground_truth():
+    trainers = {"0001": {"task_send": [_task_send(1, 200.0, 700.0)]}}
+    res = send_gate_wait_fidelity_parity(trainers, None)
+    assert res["ok"] and res.get("status") == "SKIP"
+
+
+def test_a8_skips_when_no_matching_trainer():
+    gt = {"t1_9999": SortedDict({600.0: "UN_AVL"})}
+    trainers = {"0001": {"task_send": [_task_send(1, 200.0, 700.0)]}}
+    res = send_gate_wait_fidelity_parity(trainers, gt)
+    assert res.get("status") == "SKIP"
+
+
+def test_a8_skips_when_no_gate_fields_present():
+    # sim telemetry (or telemetry predating T3.4): send_gate_wait_s/sct absent.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    trainers = {"0001": {"task_send": [
+        {"event": "task_send", "round": 1, "task_to_perform": "train"},
+    ]}}
+    res = send_gate_wait_fidelity_parity(trainers, gt)
+    assert res.get("status") == "SKIP"
+
+
+def test_a8_passes_when_observed_matches_ground_truth():
+    # Ground truth: AVL_TRAIN [0,600), UN_AVL [600,900), AVL_TRAIN [900,inf).
+    # Trainer completed compute at sct=700 (mid-outage) -> should wait 200s.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})}
+    trainers = {"0001": {"task_send": [_task_send(1, 200.0, 700.0)]}}
+    res = send_gate_wait_fidelity_parity(trainers, gt)
+    assert res["ok"], res
+    assert res["mean_err_s"] == 0.0
+    assert res["n_scored"] == 1
+
+
+def test_a8_zero_wait_when_already_available():
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})}
+    trainers = {"0001": {"task_send": [_task_send(1, 0.0, 100.0)]}}
+    res = send_gate_wait_fidelity_parity(trainers, gt)
+    assert res["ok"], res
+    assert res["mean_err_s"] == 0.0
+
+
+def test_a8_fails_on_injected_wait_drift():
+    # A promptness bug: observed wait is 300s short of what ground truth says.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})}
+    trainers = {"0001": {"task_send": [_task_send(1, 50.0, 700.0)]}}  # expect 200.0
+    res = send_gate_wait_fidelity_parity(trainers, gt, mean_tol_s=10.0)
+    assert not res["ok"], res
+    assert res["mean_err_s"] == 150.0
+
+
+def test_a8_excludes_uncomparable_never_recovers_events():
+    # Trace never recovers after sct -> excluded from scoring, not penalized.
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})}
+    trainers = {"0001": {"task_send": [
+        _task_send(1, 50.0, 700.0),   # uncomparable (no recovery in trace)
+        _task_send(2, 0.0, 100.0),    # already available -> comparable, err=0
+    ]}}
+    res = send_gate_wait_fidelity_parity(trainers, gt)
+    assert res["ok"], res
+    assert res["n_events"] == 2
+    assert res["n_scored"] == 1
+    assert res["n_uncomparable"] == 1
+
+
+def test_a8_population_rollup_across_multiple_events():
+    gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})}
+    trainers = {"0001": {"task_send": [
+        _task_send(1, 200.0, 700.0),  # exact match, err=0
+        _task_send(2, 190.0, 700.0),  # err=10
+    ]}}
+    res = send_gate_wait_fidelity_parity(trainers, gt, mean_tol_s=10.0,
+                                         within_tau_s=15.0)
+    assert res["n_scored"] == 2
+    assert res["mean_err_s"] == 5.0
+    assert res["ok"]
diff --git a/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh b/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh
index 7f5b94a1e..d639ed5a8 100755
--- a/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh
+++ b/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh
@@ -69,7 +69,7 @@ src, out = sys.argv[1], sys.argv[2]
 d = yaml.safe_load(open(src))
 for e in d["experiments"]:
     h = e["aggregator"]["config_overrides"]["hyperparameters"]
-    h.update(rounds=6, max_runtime_s=180, evalEveryNRounds=2,
+    h.update(rounds=6, max_experiment_runtime_s=180, evalEveryNRounds=2,
              targetAccuracy=0.2, stableEvalsAboveTarget=2,
              min_trainers_to_start=48, min_trainers_join_timeout_s=120)
     h["checkpoint"]["every_n_rounds"] = 2
diff --git a/lib/python/examples/async_cifar10/scripts/smoke_suite.sh b/lib/python/examples/async_cifar10/scripts/smoke_suite.sh
new file mode 100755
index 000000000..a1fe02753
--- /dev/null
+++ b/lib/python/examples/async_cifar10/scripts/smoke_suite.sh
@@ -0,0 +1,467 @@
+#!/usr/bin/env bash
+# ============================================================================
+# smoke_suite.sh  —  Sequential smoke campaign with per-run timeout guard.
+#
+# Runs five ordered steps.  Each individual (baseline, mode) invocation of
+# debug_run.sh is wrapped in a wall-clock timeout: if the run does not
+# self-terminate within (runtime_s + timeout_buffer_s), it is killed via
+# SIGTERM → SIGKILL on the whole process group so no orphan trainers remain.
+# The suite then continues with the next run.
+#
+# Steps
+#   1  pytest          — unit tests (flame/tests/), expected: 536p/7s
+#   2  syn_0  sim      — byte-identity regression, all 6 baselines
+#   3  syn_20 sim      — all 6 baselines (availability active, fast mode)
+#   4  syn_20 both     — all 6 baselines × sim + real (parity gate)
+#   5  syn_50 starvation — feddance + oort, both modes (B2.0.2 regression)
+#      Expected: [SIM_STARVATION] events present, no [SIM_WALL_CEILING],
+#                self-stops via "stopping run" in both modes.
+#
+# Per-run checks (applied to the Python agg output log):
+#   stopping_run  count of "stopping run" lines — must be > 0
+#   wall_ceiling  count of [SIM_WALL_CEILING] lines — must be 0
+#   starvation    count of [SIM_STARVATION] lines — informational
+#
+# Report is written to <output-dir>/report.txt and printed at the end.
+#
+# Usage:
+#   smoke_suite.sh [OPTIONS]
+#
+# Options:
+#   --runtime-syn0-s  N    Budget (wall/vclock) for syn_0 runs     [default: 900]
+#   --runtime-syn20-s N    Budget for syn_20 runs                  [default: 1800]
+#   --runtime-syn50-s N    Budget for syn_50 starvation runs       [default: 3600]
+#   --timeout-buffer-s N   Extra wall-sec before force-kill        [default: 600]
+#   --kill-settle-s N      GPU memory settle wait after force-kill [default: 20]
+#   --steps LIST           Comma-separated steps to run (1–5)      [default: 1,2,3,4,5]
+#   --baselines NAMES      Space-separated baseline list (steps 2–4) [default: all 6]
+#   --starvation-baselines NAMES  Baselines for step 5            [default: feddance oort]
+#   --num-trainers N       Shrink the cohort below the parity config's 300
+#                          (forwarded to debug_run.sh --num-trainers on every
+#                          run) [default: "" = use the parity config's 300]
+#   --output-dir DIR       Log + report directory                  [default: /tmp/smoke_suite_<ts>]
+#   --background           Re-exec via nohup+disown and return immediately;
+#                          survives the launching shell/SSH session closing.
+#                          Prints the PID, nohup log, and report path, then
+#                          exits 0 right away — the suite keeps running
+#                          detached. Use this for unattended/overnight runs.
+#   --dry-run              Print commands without running them
+#   --help
+# ============================================================================
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+EX_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"          # async_cifar10/
+LIB_DIR="$(cd "$EX_DIR/../.." && pwd)"           # lib/python/
+DEBUG_RUN="$SCRIPT_DIR/debug_run.sh"
+
+# ── Defaults ─────────────────────────────────────────────────────────────────
+RUNTIME_SYN0_S=900
+RUNTIME_SYN20_S=1800
+RUNTIME_SYN50_S=3600
+TIMEOUT_BUFFER_S=600
+KILL_SETTLE_S=20       # GPU settle wait (seconds) after a force-killed run
+ALL_BASELINES="felix oort oort_star refl feddance fedbuff"
+STARV_BASELINES="feddance oort"
+STEPS="1,2,3,4,5"
+OUTPUT_DIR="/tmp/smoke_suite_$(date +%Y%m%d_%H%M%S)"
+DRY_RUN=0
+BACKGROUND=0
+NUM_TRAINERS=""
+
+# ── Progress counters (set after arg-parse via _compute_total_runs) ───────────
+TOTAL_RUNS=0
+COMPLETED_RUNS=0
+
+# ── Arg parsing ──────────────────────────────────────────────────────────────
+usage() {
+  grep '^#' "$0" | grep -v '^#!/' | sed 's/^# \{0,1\}//'
+  exit 0
+}
+
+ORIG_ARGS=("$@")   # preserved pre-shift for the --background re-exec below
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --runtime-syn0-s)       RUNTIME_SYN0_S="$2";    shift 2 ;;
+    --runtime-syn20-s)      RUNTIME_SYN20_S="$2";   shift 2 ;;
+    --runtime-syn50-s)      RUNTIME_SYN50_S="$2";   shift 2 ;;
+    --timeout-buffer-s)     TIMEOUT_BUFFER_S="$2";  shift 2 ;;
+    --kill-settle-s)        KILL_SETTLE_S="$2";     shift 2 ;;
+    --steps)                STEPS="$2";             shift 2 ;;
+    --baselines)            ALL_BASELINES="$2";     shift 2 ;;
+    --starvation-baselines) STARV_BASELINES="$2";   shift 2 ;;
+    --output-dir)           OUTPUT_DIR="$2";        shift 2 ;;
+    --num-trainers)         NUM_TRAINERS="$2";      shift 2 ;;
+    --dry-run)              DRY_RUN=1;              shift   ;;
+    --background)           BACKGROUND=1;           shift   ;;
+    --help|-h)              usage ;;
+    *) echo "Unknown arg: $1" >&2; usage ;;
+  esac
+done
+
+# ── --background: re-exec detached, return control immediately ───────────────
+# Guarded by SMOKE_SUITE_BG so the re-exec'd child (which still sees
+# --background in ORIG_ARGS) runs the real suite instead of looping.
+if [[ "$BACKGROUND" == "1" && -z "${SMOKE_SUITE_BG:-}" ]]; then
+  mkdir -p "$OUTPUT_DIR"
+  NOHUP_LOG="$OUTPUT_DIR/nohup.log"
+  SMOKE_SUITE_BG=1 nohup bash "$0" "${ORIG_ARGS[@]}" >"$NOHUP_LOG" 2>&1 < /dev/null &
+  disown
+  echo "[smoke_suite] backgrounded — PID $!  (survives this shell/SSH session closing)"
+  echo "[smoke_suite] nohup log : $NOHUP_LOG"
+  echo "[smoke_suite] report    : $OUTPUT_DIR/report.txt   (written when the suite finishes)"
+  echo "[smoke_suite] progress  : tail -f $NOHUP_LOG"
+  exit 0
+fi
+
+# ── Setup ────────────────────────────────────────────────────────────────────
+mkdir -p "$OUTPUT_DIR/runs"
+SUITE_LOG="$OUTPUT_DIR/suite.log"
+REPORT="$OUTPUT_DIR/report.txt"
+SUITE_START=$(date +%s)
+
+_log()  { echo "[$(date '+%F %T')] $*" | tee -a "$SUITE_LOG"; }
+_step() { _log ""; _log "══════ STEP $* ══════"; }
+
+# ── Result tracking ──────────────────────────────────────────────────────────
+# Each entry: "label|status|stopping_run|wall_ceiling|starvation"
+declare -a RUN_RESULTS=()
+
+_record() {
+  RUN_RESULTS+=("${1}|${2}|${3}|${4}|${5}")
+  COMPLETED_RUNS=$(( COMPLETED_RUNS + 1 ))
+}
+
+# ── Total-run count (computed once after arg-parse) ──────────────────────────
+_compute_total_runs() {
+  local total=0
+  local n_all; n_all=$(echo "$ALL_BASELINES" | wc -w)
+  local n_starv; n_starv=$(echo "$STARV_BASELINES" | wc -w)
+  local _s
+  IFS=',' read -ra _sa <<< "$STEPS"
+  for _s in "${_sa[@]}"; do
+    _s="${_s// /}"
+    case "$_s" in
+      1) total=$(( total + 1 )) ;;
+      2) total=$(( total + n_all )) ;;
+      3) total=$(( total + n_all )) ;;
+      4) total=$(( total + 2 * n_all )) ;;
+      5) total=$(( total + 2 * n_starv )) ;;
+    esac
+  done
+  TOTAL_RUNS=$total
+}
+
+# ── Per-run timeout wrapper ───────────────────────────────────────────────────
+# _run_baseline <label> <runtime_s> [debug_run_args...]
+#
+# Process tree (one per invocation):
+#   smoke_suite.sh
+#   └─ bash debug_run.sh          ← PGID = runner_pid (via set -m)
+#      └─ python run_experiment    ← inherits PGID (plain Popen, no setsid)
+#         ├─ python aggregator/pytorch/main_*.py   ← inherits PGID
+#         └─ python trainer/pytorch/main.py × 300  ← inherits PGID
+#
+# Termination (timeout path):
+#   1. kill -TERM -$runner_pid  → SIGTERM to whole group simultaneously.
+#      ExperimentRunner._signal_handler fires on the runner → _cleanup()
+#      (terminate_all trainers + terminate aggregator). Group members also
+#      receive SIGTERM directly, so cleanup is redundant but harmless.
+#      20s grace: gives Python time to flush files and release MQTT connections.
+#   2. kill -KILL -$runner_pid  → SIGKILL to any survivors (hung GPU op,
+#      stuck MQTT recv). OS reclaims GPU memory immediately after.
+#   3. Post-kill sweep (this script): pkill the trainer/aggregator patterns
+#      in case any process escaped the group (edge case). Then sleep
+#      KILL_SETTLE_S to let GPU memory drain before the next run allocates.
+#      Mirrors run_experiment_batch's _sweep_stragglers(), which is killed
+#      mid-execution during a hard timeout.
+#
+# Grep checks scan experiments/run_*/*_aggregator.log (NOT debug_run.out).
+# AggregatorSpawner redirects the aggregator subprocess's stdout/stderr to
+# that dedicated file; debug_run.out is only the runner's own print()s.
+#
+# Returns 0 (PASS), 1 (FAIL/ERROR), 124 (TIMEOUT).
+_run_baseline() {
+  local label="$1" runtime_s="$2"; shift 2
+  local run_dir="$OUTPUT_DIR/runs/$label"
+  mkdir -p "$run_dir"
+  local wall_timeout=$(( runtime_s + TIMEOUT_BUFFER_S ))
+
+  _log "  [$label] start (runtime=${runtime_s}s  wall_timeout=${wall_timeout}s)"
+
+  if [[ "$DRY_RUN" == "1" ]]; then
+    echo "  DRY: FLAME_LOGDIR=$run_dir bash $DEBUG_RUN $*" | tee -a "$SUITE_LOG"
+    _record "$label" SKIP 0 0 0
+    return 0
+  fi
+
+  local ts_start; ts_start=$(date +%s)
+  # Marker for finding experiment dirs (and their aggregator logs) created
+  # during this run. Touch before launch so any dir created after belongs here.
+  local ts_marker="$run_dir/.ts_start"
+  touch "$ts_marker"
+
+  # set -m (job control) forces bash to assign PGID = runner_pid to the
+  # background job regardless of whether the suite is running interactively
+  # or not.  All descendants inherit that PGID (flame's spawner.py uses plain
+  # subprocess.Popen with no start_new_session/os.setsid), so
+  # kill -TERM/-KILL on -$runner_pid reliably reaches the whole process tree.
+  # Rationale: setsid forks when the calling process is already a pg-leader
+  # (interactive terminals do this), making runner_pid point to a dead parent
+  # instead of the actual session leader → kill misses the tree entirely.
+  set -m
+  env FLAME_LOGDIR="$run_dir" bash "$DEBUG_RUN" "$@" \
+    >"$run_dir/shell.log" 2>&1 &
+  local runner_pid=$!
+  set +m
+
+  local deadline=$(( ts_start + wall_timeout ))
+  local timed_out=0
+  local _ela _kill_in _prun _pdone   # ticker temporaries
+  while kill -0 "$runner_pid" 2>/dev/null; do
+    sleep 5
+    _ela=$(( $(date +%s) - ts_start ))
+    _kill_in=$(( deadline - $(date +%s) )); [[ "$_kill_in" -lt 0 ]] && _kill_in=0
+    _prun=0; [[ "$runtime_s" -gt 0 ]] && _prun=$(( _ela * 100 / runtime_s ))
+    [[ "$_prun" -gt 100 ]] && _prun=100
+    _pdone=0; [[ "$TOTAL_RUNS" -gt 0 ]] && _pdone=$(( COMPLETED_RUNS * 100 / TOTAL_RUNS ))
+    printf '\r  %-52s  %4ds/%-4ds(%3d%%)  kill in %4ds  |  %d/%d done(%d%%)   ' \
+      "[$label]" "$_ela" "$runtime_s" "$_prun" "$_kill_in" \
+      "$COMPLETED_RUNS" "$TOTAL_RUNS" "$_pdone" >&2
+    if [[ "$(date +%s)" -ge "$deadline" ]]; then
+      printf '\n' >&2
+      _log "  [$label] TIMEOUT after ${wall_timeout}s — killing process group $runner_pid"
+      # SIGTERM first: lets ExperimentRunner._signal_handler call _cleanup()
+      # (terminate_all trainers + terminate aggregator). 20s grace lets Python
+      # flush open files and release MQTT connections before the hard kill.
+      kill -TERM -"$runner_pid" 2>/dev/null || true
+      sleep 20
+      # SIGKILL for anything that survived (hung GPU op, stuck MQTT recv).
+      kill -KILL -"$runner_pid" 2>/dev/null || true
+      wait "$runner_pid" 2>/dev/null
+      timed_out=1
+      break
+    fi
+  done
+  printf '\n' >&2
+  [[ "$timed_out" == "0" ]] && wait "$runner_pid" 2>/dev/null
+  local run_rc=$?
+
+  # ── Post-kill cleanup ─────────────────────────────────────────────────────
+  # When SIGKILL fires, run_experiment_batch's finally block (_sweep_stragglers)
+  # is in the killed group and may not complete. Replicate it here: hard-kill
+  # any surviving trainer/aggregator processes and wait for GPU memory to drain
+  # so the next run starts from a clean slate.
+  if [[ "$timed_out" == "1" ]]; then
+    _log "  [$label] post-kill sweep: clearing straggler trainer/aggregator processes"
+    pkill -9 -f "trainer/pytorch/main.py"  2>/dev/null || true
+    pkill -9 -f "aggregator/pytorch/main_" 2>/dev/null || true
+    _log "  [$label] waiting ${KILL_SETTLE_S}s for GPU memory to drain before next run"
+    sleep "$KILL_SETTLE_S"
+  fi
+
+  local elapsed=$(( $(date +%s) - ts_start ))
+
+  # ── Grep checks: scan the aggregator's dedicated log file ─────────────────
+  # AggregatorSpawner redirects the aggregator subprocess's stdout/stderr to
+  #   experiments/run_<ts>_<name>/<prefix>_aggregator.log
+  # NOT to $FLAME_LOGDIR/debug_run.out (that file is only run_experiment.py's
+  # own print()s — high-level orchestration, not FL logic messages).
+  # Scan all aggregator logs created after ts_marker (handles batches of > 1).
+  local stopping=0 ceiling=0 starv=0
+  local found_agg_logs=()
+  while IFS= read -r agg_log; do
+    [[ -f "$agg_log" ]] || continue
+    found_agg_logs+=("$agg_log")
+    stopping=$(( stopping + $(grep -ic "stopping run"       "$agg_log" 2>/dev/null || true) ))
+    ceiling=$((  ceiling  + $(grep -c  "SIM_WALL_CEILING"   "$agg_log" 2>/dev/null || true) ))
+    starv=$((    starv    + $(grep -c  "\[SIM_STARVATION\]" "$agg_log" 2>/dev/null || true) ))
+  done < <(find "$EX_DIR/experiments" -name "*_aggregator.log" -newer "$ts_marker" 2>/dev/null)
+
+  # Record aggregator log paths in the run dir for easy post-mortem access.
+  if [[ ${#found_agg_logs[@]} -gt 0 ]]; then
+    printf '%s\n' "${found_agg_logs[@]}" > "$run_dir/agg_logs.txt"
+  fi
+
+  # ── Classify ─────────────────────────────────────────────────────────────
+  local status
+  if   [[ "$timed_out" == "1" ]];    then status="TIMEOUT"
+  elif [[ "$run_rc"    != "0"  ]];   then status="ERROR(rc=$run_rc)"
+  elif [[ "$stopping"  -eq 0   ]];   then status="FAIL(no_stop)"
+  elif [[ "$ceiling"   -gt 0   ]];   then status="FAIL(wall_ceil)"
+  else                                    status="PASS"
+  fi
+
+  _log "  [$label] $status  elapsed=${elapsed}s  stopping=${stopping}  wall_ceil=${ceiling}  starvation=${starv}"
+  _record "$label" "$status" "$stopping" "$ceiling" "$starv"
+
+  [[ "$status" == "PASS" ]]
+}
+
+# Convenience: run one baseline × one mode.
+_run_one() {
+  local baseline="$1" mode="$2" trace="$3" runtime_s="$4" step_pfx="$5"
+  local label="${step_pfx}_${baseline}_${trace}_${mode}"
+  local -a _nt_args=()
+  [[ -n "$NUM_TRAINERS" ]] && _nt_args=(--num-trainers "$NUM_TRAINERS")
+  _run_baseline "$label" "$runtime_s" \
+    --baselines "$baseline" --mode "$mode" --trace "$trace" --runtime-s "$runtime_s" \
+    "${_nt_args[@]}" \
+    || true   # never abort the suite on a single run failure
+}
+
+# ── Step 1: Unit tests ───────────────────────────────────────────────────────
+step1_pytest() {
+  _step "1  Unit tests"
+  local conda_env="${FLAME_CONDA_ENV:-dg_flame}"
+
+  if [[ "$DRY_RUN" == "1" ]]; then
+    echo "  DRY: conda run -n $conda_env python -m pytest $LIB_DIR/tests/ -q --tb=short" \
+      | tee -a "$SUITE_LOG"
+    _record "s1_pytest" SKIP 0 0 0
+    return
+  fi
+
+  local pytest_log="$OUTPUT_DIR/runs/s1_pytest.log"
+  mkdir -p "$OUTPUT_DIR/runs"
+  conda run -n "$conda_env" \
+    python -m pytest "$LIB_DIR/tests/" -q --tb=short \
+    >"$pytest_log" 2>&1
+  local rc=$?
+  local summary; summary=$(tail -3 "$pytest_log")
+  if [[ "$rc" == "0" ]]; then
+    _log "  PASS  $summary"
+    _record "s1_pytest" PASS 0 0 0
+  else
+    _log "  FAIL  $summary"
+    _log "  Full log: $pytest_log"
+    _record "s1_pytest" "FAIL(rc=$rc)" 0 0 0
+  fi
+}
+
+# ── Step 2: syn_0 regression (sim only) ──────────────────────────────────────
+step2_syn0_sim() {
+  _step "2  syn_0 regression — sim, all 6 baselines"
+  _log "  (gate-ON with always-available trace; sim completes in << runtime_s wall-seconds)"
+  for bl in $ALL_BASELINES; do
+    _run_one "$bl" sim syn_0 "$RUNTIME_SYN0_S" s2
+  done
+}
+
+# ── Step 3: syn_20 sim ───────────────────────────────────────────────────────
+step3_syn20_sim() {
+  _step "3  syn_20 — sim, all 6 baselines"
+  for bl in $ALL_BASELINES; do
+    _run_one "$bl" sim syn_20 "$RUNTIME_SYN20_S" s3
+  done
+}
+
+# ── Step 4: syn_20 both modes ────────────────────────────────────────────────
+step4_syn20_both() {
+  _step "4  syn_20 — sim then real, all 6 baselines"
+  _log "  (real runs take ~${RUNTIME_SYN20_S}s wall each; total step ~$(( $(wc -w <<< "$ALL_BASELINES") * RUNTIME_SYN20_S / 60 ))+ min)"
+  for bl in $ALL_BASELINES; do
+    _run_one "$bl" sim  syn_20 "$RUNTIME_SYN20_S" s4
+    _run_one "$bl" real syn_20 "$RUNTIME_SYN20_S" s4
+  done
+}
+
+# ── Step 5: syn_50 starvation regression ─────────────────────────────────────
+step5_syn50_starvation() {
+  _step "5  syn_50 starvation — $STARV_BASELINES, both modes (B2.0.2 regression)"
+  _log "  Expected: [SIM_STARVATION] present, no [SIM_WALL_CEILING], self-stops cleanly."
+  for bl in $STARV_BASELINES; do
+    _run_one "$bl" sim  syn_50 "$RUNTIME_SYN50_S" s5
+    _run_one "$bl" real syn_50 "$RUNTIME_SYN50_S" s5
+  done
+}
+
+# ── Final report ─────────────────────────────────────────────────────────────
+_final_report() {
+  local total=${#RUN_RESULTS[@]}
+  local pass=0 fail=0 timeout=0 skip=0 error=0
+
+  {
+    local divider; divider=$(printf '═%.0s' {1..68})
+    echo "$divider"
+    echo "  SMOKE SUITE REPORT"
+    printf "  Generated  : %s\n"  "$(date '+%F %T')"
+    printf "  Duration   : %ds\n" "$(( $(date +%s) - SUITE_START ))"
+    printf "  Output     : %s\n"  "$OUTPUT_DIR"
+    printf "  Runtimes   : syn_0=%ss  syn_20=%ss  syn_50=%ss  buffer=%ss  kill_settle=%ss\n" \
+      "$RUNTIME_SYN0_S" "$RUNTIME_SYN20_S" "$RUNTIME_SYN50_S" "$TIMEOUT_BUFFER_S" "$KILL_SETTLE_S"
+    echo "$divider"
+    echo ""
+    printf "%-48s  %-20s  %8s  %9s  %11s\n" \
+      "RUN" "STATUS" "stop_run" "wall_ceil" "starvation"
+    printf "%-48s  %-20s  %8s  %9s  %11s\n" \
+      "$(printf '%0.s-' {1..48})" "$(printf '%0.s-' {1..20})" "--------" "---------" "-----------"
+
+    for entry in "${RUN_RESULTS[@]}"; do
+      IFS='|' read -r label status stopping ceiling starv <<< "$entry"
+      case "$status" in
+        PASS)    (( pass++    )) ;;
+        SKIP)    (( skip++    )) ;;
+        TIMEOUT) (( timeout++ )) ;;
+        ERROR*)  (( error++   )) ;;
+        FAIL*)   (( fail++    )) ;;
+      esac
+      printf "%-48s  %-20s  %8s  %9s  %11s\n" \
+        "$label" "$status" "$stopping" "$ceiling" "$starv"
+    done
+
+    echo ""
+    echo "TOTAL $total runs:  PASS=$pass  FAIL=$fail  ERROR=$error  TIMEOUT=$timeout  SKIP=$skip"
+    echo ""
+
+    # Attention list
+    local bad=()
+    for entry in "${RUN_RESULTS[@]}"; do
+      IFS='|' read -r label status _ _ _ <<< "$entry"
+      case "$status" in PASS|SKIP) ;; *) bad+=("  $label  →  $status") ;; esac
+    done
+    if [[ ${#bad[@]} -gt 0 ]]; then
+      echo "Runs needing investigation:"
+      printf '%s\n' "${bad[@]}"
+      echo ""
+      echo "Logs:  <label>/shell.log       — debug_run.sh + run_experiment.py stdout"
+      echo "       <label>/debug_run.out   — run_experiment.py stdout (FL orchestration)"
+      echo "       <label>/agg_logs.txt    — paths to aggregator log(s) for this run"
+      echo "       (aggregator logs live in experiments/run_*/..._aggregator.log)"
+      echo "       (grep 'stopping run'/'SIM_WALL_CEILING' in the aggregator log)"
+      echo "  All under: $OUTPUT_DIR/runs/"
+    else
+      echo "All runs clean."
+    fi
+    echo "$divider"
+  } | tee "$REPORT" | tee -a "$SUITE_LOG"
+
+  # Return non-zero if anything went wrong
+  (( fail + error + timeout == 0 ))
+}
+
+# ── Main ─────────────────────────────────────────────────────────────────────
+_compute_total_runs
+_log "Smoke suite started  (total runs: $TOTAL_RUNS)"
+_log "  output      : $OUTPUT_DIR"
+_log "  steps       : $STEPS"
+_log "  baselines   : $ALL_BASELINES"
+_log "  starvation  : $STARV_BASELINES"
+_log "  num_trainers: ${NUM_TRAINERS:-300(parity config default)}"
+_log "  runtimes    : syn_0=${RUNTIME_SYN0_S}s  syn_20=${RUNTIME_SYN20_S}s  syn_50=${RUNTIME_SYN50_S}s  buffer=${TIMEOUT_BUFFER_S}s  kill_settle=${KILL_SETTLE_S}s"
+
+IFS=',' read -ra _steps_arr <<< "$STEPS"
+for s in "${_steps_arr[@]}"; do
+  s="${s// /}"   # strip any accidental spaces
+  case "$s" in
+    1) step1_pytest ;;
+    2) step2_syn0_sim ;;
+    3) step3_syn20_sim ;;
+    4) step4_syn20_both ;;
+    5) step5_syn50_starvation ;;
+    *) _log "Unknown step '$s' (valid: 1–5)" ;;
+  esac
+done
+
+_final_report
diff --git a/lib/python/examples/async_cifar10/trainer/pytorch/conftest.py b/lib/python/examples/async_cifar10/trainer/pytorch/conftest.py
new file mode 100644
index 000000000..91fed2c16
--- /dev/null
+++ b/lib/python/examples/async_cifar10/trainer/pytorch/conftest.py
@@ -0,0 +1,20 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Two sys.path entries main.py needs that pytest's default package-import
+(rootdir=lib/python, so this module is examples.async_cifar10.trainer.pytorch)
+doesn't provide on its own:
+
+- this directory itself, so main.py's own sibling-style imports
+  (`from memory_profiler import ...`) resolve, matching how it's actually
+  launched in production (as a script, run from within this directory);
+- `examples/async_cifar10/`, so tests here can import main.py via its full
+  package path (`from trainer.pytorch.main import ...`) without needing
+  `examples.async_cifar10.` prefixed on every import.
+"""
+
+import sys
+from pathlib import Path
+
+_HERE = Path(__file__).parent
+sys.path.insert(0, str(_HERE))
+sys.path.insert(0, str(_HERE.parents[1]))
diff --git a/lib/python/examples/async_cifar10/trainer/pytorch/main.py b/lib/python/examples/async_cifar10/trainer/pytorch/main.py
index 790710baf..f593c7087 100644
--- a/lib/python/examples/async_cifar10/trainer/pytorch/main.py
+++ b/lib/python/examples/async_cifar10/trainer/pytorch/main.py
@@ -173,6 +173,11 @@ def __init__(self, config: Config, battery_threshold, time_mode="simulated") ->
         self.time_mode = str(time_mode)
         self.simulated = self.time_mode == "simulated"
         self._sim_send_ts = None  # set by aggregator stamp on each task (sim mode)
+        # Aggregator's trace-read origin (agg_start_time_ts), broadcast on every
+        # dispatch in real mode -- see AGG_START_TS in trainer.py:_fetch_weights.
+        # None until the first message arrives; _sim_now() falls back to
+        # trainer_start_ts until then (Batch 3 T3.0).
+        self._agg_start_origin = None
 
         # Use the battery_threshold to determine the
         # avl_events_3_state config. Default to 50 if not provided
@@ -244,6 +249,17 @@ def parse_trace(value):
                 f"No avl_events set for trainer id {self.trainer_id} since state not specified."
             )
 
+        # Startup signature: a shared trace_hash across many trainer_ids in the
+        # same run's logs means trace assignment isn't individualized.
+        if hasattr(self, "state_avl_event_ts"):
+            events = self.state_avl_event_ts
+            trace_hash = hashlib.md5(repr(events).encode()).hexdigest()[:8]
+            logger.info(
+                f"[AVAIL_TRACE] trainer_id={self.trainer_id} "
+                f"trace={self.client_notify['trace']!r} n_events={len(events)} "
+                f"first_events={events[:2]} trace_hash={trace_hash}"
+            )
+
         self.avl_state = TrainerAvailState.AVL_TRAIN
 
         # flag to decide whether the trainer upon unavailability will wait or exit
@@ -309,15 +325,29 @@ def check_and_sleep(self):
         pass
 
     def _sim_now(self) -> float:
-        """Wall-elapsed (real) or last-task sim_send_ts (simulated)."""
+        """Wall-elapsed since the aggregator's trace-read origin (real) or
+        last-task sim_send_ts (simulated).
+
+        Real mode anchors to `_agg_start_origin` (broadcast by the aggregator)
+        rather than this trainer's own `trainer_start_ts`, so every trainer's
+        trace lookups share the aggregator's exact origin -- a local
+        per-trainer origin would reintroduce a join-ramp-style skew (same
+        class of bug as B2.0.3). Falls back to `trainer_start_ts` only until
+        the first dispatch arrives.
+        """
         if self.simulated:
             return float(self._sim_send_ts) if self._sim_send_ts is not None else 0.0
-        return time.time() - self.trainer_start_ts
-
-    def _refresh_avl_for_sim(self) -> None:
-        """Advance availability state to current sim-time (sim mode only)."""
-        if not self.simulated:
-            return
+        origin = self._agg_start_origin if self._agg_start_origin is not None else self.trainer_start_ts
+        return time.time() - origin
+
+    def _refresh_avl_state(self) -> None:
+        """Advance availability state to the current point in the trace, both
+        modes -- pop every due transition, not just the next one, so a
+        trainer that's been busy computing catches up on all of them, not
+        just the first. One code path for both modes: `_sim_now()` already
+        dispatches on `self.simulated` internally, so this needs no mode gate
+        of its own.
+        """
         guard = 0
         while (
             self.state_avl_event_ts
@@ -334,7 +364,7 @@ def check_and_update_state_avl(self):
                 # the current sim-time (no speedup_factor in either mode).
                 sim_elapsed = self._sim_now()
                 if sim_elapsed >= self.state_avl_event_ts[0][0]:
-                    state_to_set = self.state_avl_event_ts.pop(0)[1]
+                    due_ts, state_to_set = self.state_avl_event_ts.pop(0)
                     old_status = self.avl_state.value
                     try:
                         self.avl_state = TrainerAvailState(state_to_set)
@@ -348,10 +378,15 @@ def check_and_update_state_avl(self):
                         f"Changed the availability status of trainer {self.trainer_id} from {old_status} to {new_status}"
                     )
                     if telemetry.is_enabled():
+                        # sim_now = the transition's own scheduled trace-time
+                        # (due_ts), not self._sim_now() at processing time --
+                        # correct regardless of catch-up delay, fixing sim
+                        # mode's frozen-clock-during-idle gap at the source.
                         ev, fields = build_avail_change(
                             round_num=int(getattr(self, "_round", 0)),
                             old_state=str(old_status),
                             new_state=str(new_status),
+                            sim_now=due_ts,
                         )
                         telemetry.emit(ev, **fields)
                     if self.client_notify["enabled"] == "True":
@@ -676,34 +711,20 @@ def train(self) -> None:
             return
         # telemetry: measure time spent waiting on availability (vs. computing)
         _wait_time_s = 0.0
-        # simulated mode: refresh availability from the trace at this task's
-        # sim-time before deciding (sim-time advances only with new tasks).
-        self._refresh_avl_for_sim()
-        # don't enter the if condition if the three_state_avl switch is off
-        # if we are checking for three_state_avl - check if the mechanism is to wait or exit
+        # Refresh availability from the trace at this task's current time
+        # (both modes) before deciding.
+        self._refresh_avl_state()
+        # [SEND_GATE] compute-completes / gate-the-send model (UNAVAILABILITY_DESIGN
+        # §8.3): training always runs to completion regardless of avl_state — a
+        # trainer dispatched while AVL_* that goes UN_AVL (or AVL_EVAL) mid-flight is
+        # NOT skipped here. The upload is gated instead, in _send_weights, where the
+        # completed result is held and delivered once the trainer is AVL_* again.
         if self.avl_state != TrainerAvailState.AVL_TRAIN:
-            if self.simulated:
-                # sim-time can't advance while we block, so a real-time wait
-                # would hang. The aggregator selects available trainers; being
-                # unavailable here means skip this task (it will re-select).
-                logger.info(
-                    f"Trainer id {self.trainer_id} not available to train "
-                    f"(simulated, sim_t={self._sim_now()}); skipping task."
-                )
-                return
-            if self.wait_until_next_avl == "True":
-                logger.info(
-                    f"Trainer id {self.trainer_id} is not available to train. Waiting for it to be available"
-                )
-                _wait_start = time.time()
-                while self.avl_state != TrainerAvailState.AVL_TRAIN:
-                    time.sleep(1)
-                _wait_time_s = time.time() - _wait_start
-            else:
-                logger.info(
-                    f"Trainer id {self.trainer_id} is not available to train. Exiting training."
-                )
-                return
+            logger.info(
+                f"Trainer {self.trainer_id} training while avl_state="
+                f"{self.avl_state.value} (compute always completes; the send-time "
+                f"gate withholds the upload if still UN_AVL)."
+            )
 
         logger.info(f"Trainer {self.trainer_id} available to train")
 
@@ -1007,37 +1028,24 @@ def evaluate(self) -> None:
         # Implement only forward pass evaluate if the trainer is available to train or to evaluate
         # Evaluate after train is written in the train_epoch method itself
 
-        # Evaluate will be skipped if one of these three is satisfied:
+        # Evaluate will be skipped if one of these two is satisfied:
         # 1. task_to_perform is train
         # 2. switch to check for three_state_avl is off
-        # 3. Trainer is unavailable and we don't want it to wait for availability
-        if (
-            self.task_to_perform != "eval"
-            or self.client_notify["trace"] == "two_state"
-            or (
-                self.avl_state == TrainerAvailState.UN_AVL
-                and self.wait_until_next_avl == "False"
-            )
-        ):
+        # Availability no longer gates the eval task-start (§8.3 compute-completes
+        # model, mirrors train()) — only the send-time gate withholds the upload.
+        if self.task_to_perform != "eval" or self.client_notify["trace"] == "two_state":
             logger.warning(
                 f"Evaluate (forward pass) will not be run for trainer id {self.trainer_id}. task_to_perform = {self.task_to_perform} and trainer avl_state = {self.avl_state.value} and wait_until_next_avl = {self.wait_until_next_avl}"
             )
             return
 
-        # simulated mode: refresh availability at this task's sim-time.
-        self._refresh_avl_for_sim()
+        # Refresh availability at this task's current time (both modes).
+        self._refresh_avl_state()
         if self.avl_state == TrainerAvailState.UN_AVL:
-            if self.simulated:
-                logger.info(
-                    f"Trainer id {self.trainer_id} unavailable for eval "
-                    f"(simulated, sim_t={self._sim_now()}); skipping."
-                )
-                return
-            logger.warning(
-                f"Trainer id {self.trainer_id} is not available to perform forward pass evaluate. Waiting for it to be available"
+            logger.info(
+                f"Trainer {self.trainer_id} evaluating while avl_state=UN_AVL "
+                f"(compute always completes; the send-time gate withholds the upload)."
             )
-            while self.avl_state == TrainerAvailState.UN_AVL:
-                time.sleep(1)
 
         # Use the same currently-visible data as training (no-op if off)
         if self.data_streaming_enabled:
diff --git a/lib/python/examples/async_cifar10/trainer/pytorch/test_agg_start_ts_sim_now.py b/lib/python/examples/async_cifar10/trainer/pytorch/test_agg_start_ts_sim_now.py
new file mode 100644
index 000000000..e1f44ca19
--- /dev/null
+++ b/lib/python/examples/async_cifar10/trainer/pytorch/test_agg_start_ts_sim_now.py
@@ -0,0 +1,44 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.0: PyTorchCifar10Trainer._sim_now()'s real-mode branch.
+
+Real mode anchors to `_agg_start_origin` (broadcast by the aggregator and
+cached by flame.mode.horizontal.syncfl.trainer.Trainer -- see
+lib/python/tests/mode/test_agg_start_ts_broadcast.py for that half) rather
+than this trainer's own `trainer_start_ts`, so every trainer's trace lookups
+share the exact origin the aggregator uses. See UNAVAILABILITY_DESIGN.md
+Batch 3 T3.0.
+"""
+
+import time
+
+import pytest
+
+from trainer.pytorch.main import PyTorchCifar10Trainer
+
+
+def _make(*, simulated, sim_send_ts=None, agg_start_origin=None, trainer_start_ts=None):
+    t = PyTorchCifar10Trainer.__new__(PyTorchCifar10Trainer)
+    t.simulated = simulated
+    t._sim_send_ts = sim_send_ts
+    t._agg_start_origin = agg_start_origin
+    t.trainer_start_ts = trainer_start_ts if trainer_start_ts is not None else time.time()
+    return t
+
+
+class TestSimNowRealModeUsesSharedOrigin:
+    def test_uses_broadcast_origin_when_available(self):
+        now = time.time()
+        t = _make(
+            simulated=False, agg_start_origin=now - 50.0, trainer_start_ts=now - 999.0
+        )
+        assert t._sim_now() == pytest.approx(50.0, abs=0.5)
+
+    def test_falls_back_to_trainer_start_ts_before_first_dispatch(self):
+        now = time.time()
+        t = _make(simulated=False, agg_start_origin=None, trainer_start_ts=now - 12.0)
+        assert t._sim_now() == pytest.approx(12.0, abs=0.5)
+
+    def test_sim_mode_unaffected_by_origin_fields(self):
+        t = _make(simulated=True, sim_send_ts=88.0, agg_start_origin=12345.0)
+        assert t._sim_now() == 88.0
diff --git a/lib/python/examples/async_cifar10/trainer/pytorch/test_avail_change_due_ts.py b/lib/python/examples/async_cifar10/trainer/pytorch/test_avail_change_due_ts.py
new file mode 100644
index 000000000..a6f0226b2
--- /dev/null
+++ b/lib/python/examples/async_cifar10/trainer/pytorch/test_avail_change_due_ts.py
@@ -0,0 +1,109 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 4 finding 2: `avail_change.sim_now` must be the transition's own
+scheduled trace-time, not `_sim_now()` at processing time.
+
+Regression target: sim-mode `_sim_now()` returns the frozen `_sim_send_ts`
+from the trainer's last dispatch. A trainer that goes quiet (correctly
+withheld/evicted as UN_AVL, so no longer dispatched) has a stale `_sim_now()`
+for as long as it stays quiet -- if a *later* catch-up call stamped
+`sim_now=self._sim_now()`, every transition flushed in that catch-up would be
+mis-recorded at the stale/late instant instead of its true trace time. Using
+the transition's own `state_avl_event_ts[0][0]` (which the trainer already
+has locally, loaded from the trace at init) instead is correct regardless of
+when the catch-up actually happens. See UNAVAILABILITY_DESIGN.md, Batch 4
+finding 2, and test_refresh_avl_state.py for the sibling real-mode coverage.
+"""
+
+from flame.config import TrainerAvailState
+from trainer.pytorch.main import PyTorchCifar10Trainer
+
+
+def _make_trainer(*, simulated, sim_send_ts, events):
+    t = PyTorchCifar10Trainer.__new__(PyTorchCifar10Trainer)
+    t.simulated = simulated
+    t._sim_send_ts = sim_send_ts
+    t._agg_start_origin = None
+    t.trainer_start_ts = 0.0
+    t.trainer_id = "trainer-under-test"
+    t._round = 7
+    t.cm = object()  # only needs to be truthy/non-None
+    t.state_avl_event_ts = list(events)
+    t.avl_state = TrainerAvailState.AVL_TRAIN
+    t.client_notify = {"enabled": "False"}
+    return t
+
+
+class TestAvailChangeSimNowIsDueTs:
+    def test_sim_now_uses_transition_due_ts_not_processing_time(self, monkeypatch):
+        """Catch-up long after the transition was due still records its TRUE
+        trace time, not the (much later) instant it happened to be noticed."""
+        import trainer.pytorch.main as main_mod
+
+        captured = []
+        monkeypatch.setattr(main_mod.telemetry, "is_enabled", lambda: True)
+        monkeypatch.setattr(
+            main_mod.telemetry, "emit",
+            lambda ev, **fields: captured.append(fields),
+        )
+
+        # Transition was due at trace-time 600.0; the trainer only gets
+        # around to processing it at sim_send_ts=890.0 (a very late catch-up,
+        # e.g. the Batch 4 finding-1 EOT wake-up after a long idle stretch).
+        t = _make_trainer(
+            simulated=True, sim_send_ts=890.0,
+            events=[(600.0, "UN_AVL")],
+        )
+        t.check_and_update_state_avl()
+
+        assert t.avl_state == TrainerAvailState.UN_AVL
+        assert len(captured) == 1
+        assert captured[0]["sim_now"] == 600.0  # the transition's own due time
+        assert captured[0]["sim_now"] != 890.0  # NOT processing-time
+
+    def test_multi_transition_catchup_each_gets_its_own_due_ts(self, monkeypatch):
+        """A burst catch-up (several missed transitions popped in sequence)
+        stamps each event with ITS OWN due time, not the burst's shared
+        processing time -- this is what lets duration-weighted fidelity
+        checks (A6) reconstruct the correct timeline even when every
+        transition is only discovered in one late catch-up call."""
+        import trainer.pytorch.main as main_mod
+
+        captured = []
+        monkeypatch.setattr(main_mod.telemetry, "is_enabled", lambda: True)
+        monkeypatch.setattr(
+            main_mod.telemetry, "emit",
+            lambda ev, **fields: captured.append(fields),
+        )
+
+        t = _make_trainer(
+            simulated=True, sim_send_ts=901.5,
+            events=[(600.0, "UN_AVL"), (750.0, "AVL_TRAIN"), (800.0, "UN_AVL")],
+        )
+        while t.state_avl_event_ts and t._sim_now() >= t.state_avl_event_ts[0][0]:
+            t.check_and_update_state_avl()
+
+        assert t.avl_state == TrainerAvailState.UN_AVL
+        assert [c["sim_now"] for c in captured] == [600.0, 750.0, 800.0]
+
+    def test_real_mode_unaffected_still_uses_due_ts(self, monkeypatch):
+        """Real mode's clock never freezes, but the fix applies uniformly --
+        due_ts is at least as correct as (and simpler than) re-deriving it
+        from a live wall-clock read at processing time."""
+        import trainer.pytorch.main as main_mod
+
+        captured = []
+        monkeypatch.setattr(main_mod.telemetry, "is_enabled", lambda: True)
+        monkeypatch.setattr(
+            main_mod.telemetry, "emit",
+            lambda ev, **fields: captured.append(fields),
+        )
+
+        import time
+
+        t = _make_trainer(simulated=False, sim_send_ts=None, events=[(30.0, "UN_AVL")])
+        t._agg_start_origin = time.time() - 40.0  # 40s of trace-elapsed real time
+        t.check_and_update_state_avl()
+
+        assert t.avl_state == TrainerAvailState.UN_AVL
+        assert captured[0]["sim_now"] == 30.0
diff --git a/lib/python/examples/async_cifar10/trainer/pytorch/test_refresh_avl_state.py b/lib/python/examples/async_cifar10/trainer/pytorch/test_refresh_avl_state.py
new file mode 100644
index 000000000..f776b1044
--- /dev/null
+++ b/lib/python/examples/async_cifar10/trainer/pytorch/test_refresh_avl_state.py
@@ -0,0 +1,95 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.1b: `_refresh_avl_state()` transitions correctly in real mode,
+anchored to the T3.0-broadcast origin -- one code path for both modes now,
+not a sim-only gated wrapper plus a separate always-on background thread.
+
+Regression target: `_refresh_avl_for_sim` (the old name) was a real no-op in
+real mode (`if not self.simulated: return`). It turned out not to be why real
+trainers never tracked the trace live (that was `debug_run.sh` never wiring
+`client_notify.trace` -- Challenges §5 item 20 / T3.1a), but it was still
+real dead code. This test would have failed under the old implementation.
+"""
+
+from flame.config import TrainerAvailState
+from trainer.pytorch.main import PyTorchCifar10Trainer
+
+
+def _make_trainer(*, simulated, agg_start_origin, now, events):
+    t = PyTorchCifar10Trainer.__new__(PyTorchCifar10Trainer)
+    t.simulated = simulated
+    t._sim_send_ts = now if simulated else None
+    t._agg_start_origin = agg_start_origin
+    t.trainer_start_ts = 0.0
+    t.trainer_id = "trainer-under-test"
+    t._round = 0
+    t.cm = object()  # only needs to be truthy/non-None
+    t.state_avl_event_ts = list(events)
+    t.avl_state = TrainerAvailState.AVL_TRAIN
+    t.client_notify = {"enabled": "False"}
+    return t
+
+
+class TestRefreshAvlStateRealMode:
+    def test_pops_a_due_transition(self):
+        import time as _time
+
+        now = _time.time()
+        origin = now - 30.0  # 30s of trace-elapsed time
+        t = _make_trainer(
+            simulated=False,
+            agg_start_origin=origin,
+            now=None,
+            events=[(20.0, "UN_AVL"), (60.0, "AVL_TRAIN")],
+        )
+        t._refresh_avl_state()
+        assert t.avl_state == TrainerAvailState.UN_AVL
+        assert t.state_avl_event_ts == [(60.0, "AVL_TRAIN")]  # only the due one popped
+
+    def test_catches_up_multiple_missed_transitions(self):
+        import time as _time
+
+        now = _time.time()
+        origin = now - 100.0  # far past every scheduled transition below
+        t = _make_trainer(
+            simulated=False,
+            agg_start_origin=origin,
+            now=None,
+            events=[(10.0, "UN_AVL"), (20.0, "AVL_TRAIN"), (30.0, "UN_AVL")],
+        )
+        t._refresh_avl_state()
+        assert t.avl_state == TrainerAvailState.UN_AVL  # last of the three due events
+        assert t.state_avl_event_ts == []
+
+    def test_no_due_transition_leaves_state_untouched(self):
+        import time as _time
+
+        now = _time.time()
+        origin = now - 5.0  # only 5s of trace-elapsed time
+        t = _make_trainer(
+            simulated=False,
+            agg_start_origin=origin,
+            now=None,
+            events=[(600.0, "UN_AVL")],
+        )
+        t._refresh_avl_state()
+        assert t.avl_state == TrainerAvailState.AVL_TRAIN
+        assert t.state_avl_event_ts == [(600.0, "UN_AVL")]
+
+    def test_real_mode_is_not_a_no_op_regression_guard(self):
+        """The historical bug: real mode never called through to
+        check_and_update_state_avl at all. Assert it's reachable now."""
+        import time as _time
+
+        now = _time.time()
+        t = _make_trainer(
+            simulated=False,
+            agg_start_origin=now - 1000.0,
+            now=None,
+            events=[(1.0, "UN_AVL")],
+        )
+        assert t.avl_state == TrainerAvailState.AVL_TRAIN
+        t._refresh_avl_state()
+        assert t.avl_state != TrainerAvailState.AVL_TRAIN, (
+            "real-mode _refresh_avl_state() must not be a no-op"
+        )
diff --git a/lib/python/examples/fwdllm/simulate_fwdllm.md b/lib/python/examples/fwdllm/simulate_fwdllm.md
index b011639d2..adb27b247 100644
--- a/lib/python/examples/fwdllm/simulate_fwdllm.md
+++ b/lib/python/examples/fwdllm/simulate_fwdllm.md
@@ -1,324 +1,278 @@
-# High-Fidelity Simulator for FwdLLM — Staged Parity Plan
-
-Pickup-ready design for porting the **high-fidelity sim + parity checker** to the `fwdllm` example
-across the **fluxtune / fwdllm / fwdllm++** baselines.
-
-**Prerequisites (read first):** [async_cifar10/PARITY.md](../async_cifar10/PARITY.md) — the proven
-methodology this plan reuses wholesale (the ladder §1–§2, role/tier tags, dependency gating, the
-landed sim mechanisms in §3, the workflow policy + run-length budget). This doc only states the
-**fwdllm deltas**; everything not redefined here is inherited from PARITY.md unchanged.
-
-**Scope of this round:** 100% trainer availability for ALL trainers. Unavailability is deferred and
-follows [async_cifar10/UNAVAILABILITY_DESIGN.md](../async_cifar10/UNAVAILABILITY_DESIGN.md) as its
-template (per-baseline source of truth, withhold-then-deliver); §F.7 keeps the `track_trainer_avail`
-seam wired-but-inert so it turns on later without rework. Assumes the launcher-script port (same shape
-as async_cifar10's `debug_run.sh` + `expt_scripts_2026/*.yaml`) has landed.
+# High-Fidelity Simulator for FwdLLM -- Design & Staged Build Plan
+
+**Design-only.** This document is the plan for building a high-fidelity **simulated-clock** runner
+for the `fwdllm` example (FedFwd / forward-gradient FL) that reaches **real<->sim parity** across the
+**fluxtune / fwdllm / fwdllm++** baselines, at **100% availability (syn_0)** and under
+**unavailability (syn_20, syn_50, mobiperf)**. The implementation is a **future branch/PR**; nothing
+here is built yet.
+
+**Prerequisites (read first):**
+- [async_cifar10/PARITY.md](../async_cifar10/PARITY.md) -- the parity methodology (the ladder §1, roles/
+  tiers/dependency-gating, workflow policy, run-length budget, landed sim mechanisms §3). **fwdllm's
+  own rung catalog is PARITY.md §F** (modified rungs, the variance-cadence layer). This doc references
+  §F for rung *definitions* and does not duplicate them; it states the fwdllm **build deltas**.
+- [async_cifar10/UNAVAILABILITY_DESIGN.md](../async_cifar10/UNAVAILABILITY_DESIGN.md) -- the availability
+  substrate this reuses wholesale (ClientAvailability mixin, trace-read effect path, the two flag axes,
+  send-gate/deliver-late-stale, two-ledger discipline, starvation self-termination, the ground-truth
+  fidelity rungs A6/A7/A8/K11). fwdllm inherits it via the aggregator class chain (§A).
+
+**Starting reality (why this is real work, not a re-label):** FedFwd has **no simulated-clock support
+today** -- every launcher yaml is `time_mode: real`, and the trainer emulates delay with a real
+`time.sleep` (`trainer/forward_training/FedSgdTrainer.py:481` `_emulate_training_delay`, called at
+`:523`; explicit note `trainer/main.py:57-78`). The aggregator machinery for a virtual clock is
+*inherited but not driven* (§A). Adding the sim clock + wiring unavailability into the
+variance-gated gradient loop is the build.
 
 **Decisions locked (kickoff):**
-- A trusted **real** wall-clock run is the reference per baseline (as in async_cifar10). Parity ≠
-  tuning sim to real; real must pass `validate_real` admissibility first (§F.6).
-- The parity checker **extends the shared `async_cifar10/scripts/parity` engine** — fwdllm rungs are
-  *added*, the engine is reused.
-- The fluxtune / fwdllm / fwdllm++ → config mapping is **user-supplied** (§C, the one blocking gap).
+- A trusted **real** wall-clock run is the reference per baseline (as in async_cifar10). Parity != tuning
+  sim to real; real must pass `validate_real` admissibility first.
+- The parity checker **extends the shared `async_cifar10/scripts/parity` engine** -- fwdllm rungs are
+  *added* (PARITY.md §F is their catalog), the engine is reused.
+- The fluxtune / fwdllm / fwdllm++ -> config mapping is **resolved** from the landed launcher configs
+  (§C); it is no longer a blocking gap.
 
 ---
 
-## §A  Already done & directly reusable (start here)
+## §A  Already on the class (inherited) vs. NOT yet wired
 
-The high-fidelity sim is a **flame-core** capability. FwdLLM's aggregator inherits **AsyncTopAgg**, so
-most machinery is already *on the class* — the work is **wiring it into fwdllm's gradient loop and
-trainer**, not re-implementing it.
+The virtual clock is a **flame-core** capability. fwdllm's aggregator is
+`examples/fwdllm/aggregator/FedSgdAggregator.py` -> `flame/mode/horizontal/syncfl/fwdllm_aggregator.py::
+TopAggregator(AsyncTopAgg)` -> `asyncfl.TopAggregator` -> `syncfl.TopAggregator(ClientAvailability, Role)`.
+So both the vclock machinery **and** the availability substrate are already **on the instance** -- the
+work is **wiring them into fwdllm's gradient loop + trainer**, not re-implementing them.
 
 ### A.1  Aggregator spine (inherited, baseline-agnostic)
-`Role → syncfl.TopAggregator → asyncfl.TopAggregator (AsyncTopAgg) → syncfl.fwdllm_aggregator →
-examples/fwdllm FedSGDAggregator`. Already on the instance (from `asyncfl/top_aggregator.py`):
-
-| Mechanism | Status for fwdllm |
+| Mechanism (from `asyncfl/top_aggregator.py`) | Status for fwdllm |
 |---|---|
 | Virtual clock `_vclock`, `_advance_sim_clock` (`vclock = max(vclock, sct)`) | inherited; **NOT yet driven** by the grad loop |
-| §3.drain sct-ordered drain `_sim_recv_min` | inherited; **bypassed** (fwdllm uses raw `recv_fifo`) |
+| §3.drain sct-ordered drain `_sim_recv_min` | inherited; **bypassed** (fwdllm's `_aggregate_grads_async` uses raw `recv_fifo`) |
 | §3.resid one-in-flight residence `_sim_hold_busy_slots` | inherited; **bypassed** |
-| §4.5/§4.9 sct-gated pool exclusion / carry-over (oort overlay) | available if a baseline uses oort selection |
+| §4.5/§4.9 sct-gated pool exclusion / carry-over (oort overlay) | available if a baseline selects via oort (fluxtune) |
+| `ClientAvailability` substrate (trace-read gate, two ledgers, proactive evict, starvation advance) | inherited; **NOT yet wired** into the fwdllm grad loop |
 
 ### A.2  Selector + duration signal (already wired)
 - §S.dur duration helper `client_duration.py::real_client_task_train_duration` (intrinsic
-  `WALL_SEND_TS − WALL_RECV_TS`) is **already called** in `fwdllm_aggregator._process_single_trainer_message`
-  (~line 713) to set `PROP_CLIENT_TASK_TRAIN_DURATION`. No port needed.
-- Oort selector with faithful §S.pacer two-branch pacer, §S.temporal UCB, D1–D8 fixes — all in
-  `flame/selector/oort.py`, usable verbatim if a baseline selects via oort.
-- Dynamic-KC controller/policy (`flame/selector/dynamic_kc_{controller,policy}.py`) is **already
-  integrated** (`_build_dynamic_kc_metrics`, `_dynamic_kc_controller.step()`). See
-  [docs/dynamic_kc_design.md](docs/dynamic_kc_design.md).
-
-### A.3  Parity tooling (reuse wholesale, extend with fwdllm rungs)
-- Checker engine `async_cifar10/scripts/parity/{checks.py,report.py}` + `parity_check.py` — reuse,
-  add fwdllm rungs (§D). Launchers (`debug_run.sh` + `*.yaml`), plotting
-  (`scripts/analysis/analyze_run.py`), and the PARITY.md workflow policy all carry over unchanged.
-
-### A.4  NOT reusable as-is — the actual work (§B, §E)
-1. **Trainer sim path.** `FedSgdTrainer` emulates delay with real `time.sleep` (`_emulate_training_delay`,
-   `FedSgdTrainer.py:459`); it does NOT stamp a modeled completion (`SIM_COMPLETION_TS` /
-   `SIM_CLIENT_TASK_TRAIN_DURATION_S`) or `WALL_SEND_TS`/`WALL_RECV_TS` the way async_cifar10's
-   `trainer/pytorch/main.py` does. **Port required.**
-2. **Aggregator grad loop is off the virtual clock.** `_aggregate_grads_async` (~line 627) calls
-   `channel.recv_fifo(...,1)` directly and commits on wall arrival — never consults `_sim_recv_min`,
+  `WALL_SEND_TS - WALL_RECV_TS`) is already called in `fwdllm_aggregator._process_single_trainer_message`
+  (`:745`) to set `PROP_CLIENT_TASK_TRAIN_DURATION`. No port needed.
+- Oort selector (faithful §S.pacer two-branch pacer, §S.temporal UCB, D1-D8 fixes) is in
+  `flame/selector/oort.py`, usable verbatim by fluxtune (`async_oort`).
+- Dynamic-KC controller/policy (`flame/selector/dynamic_kc_{controller,policy}.py`) is already integrated
+  (`_build_dynamic_kc_metrics`, `_dynamic_kc_controller.step()`); fluxtune leaves it **disabled** (fixed
+  K/C) per its config. See [docs/dynamic_kc_design.md](docs/dynamic_kc_design.md).
+- Analysis: `scripts/analysis/analyze_run.py` is already fwdllm-aware via `telemetry_manifest.yaml`
+  (data_id/iteration_per_data_id progress hierarchy; per-category populate/partial status documented).
+
+### A.3  NOT reusable as-is -- the actual work
+1. **Trainer sim path.** `FedSgdTrainer._emulate_training_delay` (`:481`) uses real `time.sleep`; it does
+   NOT stamp a modeled completion (`SIM_COMPLETION_TS` / `SIM_CLIENT_TASK_TRAIN_DURATION_S`) or
+   `WALL_SEND_TS`/`WALL_RECV_TS` the way async_cifar10's `trainer/pytorch/main.py` does. **Port required.**
+2. **Aggregator grad loop is off the virtual clock.** `_aggregate_grads_async` (`fwdllm_aggregator.py:693`)
+   calls `channel.recv_fifo(...,1)` directly and commits on wall arrival -- never consults `_sim_recv_min`,
    never advances `_vclock`, never holds in-flight slots. **The single biggest structural port.**
-3. **Endogenous commit cadence** — variance-gated dynamic-K, not fixed-K (§B): a new emergent layer the
-   async_cifar10 ladder does not model.
+3. **Endogenous commit cadence** -- variance-gated dynamic-K, not fixed-K (PARITY.md §F.1): a new emergent
+   layer the async_cifar10 ladder does not model.
+4. **Availability telemetry.** The fwdllm trainer emits **no `EVENT_AVAIL_CHANGE`**
+   (`telemetry_manifest.yaml`: availability = *partial*), so A6/A7/A8 ground-truth rungs can't run.
+   The `avail_change` / `agg_belief_change` / `send_gate_wait` builders exist
+   (`flame/telemetry/events.py:225/521`, `task_send` fields) and just need emitting from the fwdllm
+   trainer + aggregator.
 
 ---
 
-## §B  How FwdLLM differs structurally (the crux for fidelity)
-
-async_cifar10 commits a model version every fixed **K** updates. FwdLLM does forward-gradient,
-variance-controlled, **dynamic-K** aggregation. Four differences drive every new design choice:
-
-- **B.1 Aggregates GRADIENTS (JVPs), not weights.** Trainers send forward-gradient estimates
-  (`GRADIENTS` + `GRADIENTS_FOR_VAR_CHECK`); the agg accumulates into `grad_pool` and applies a
-  server-LR SGD step at commit. Gradient **values** depend on real GPU compute (run for real in sim) →
-  **mode-invariant** given identical input+perturbation seed. What differs across modes is **which
-  gradients arrive, in what order, against which model version** — i.e. clock+selection+ordering
-  fidelity. This is what makes the async_cifar10 ladder applicable.
-- **B.2 Commit cadence is ENDOGENOUS (variance-gated dynamic-K).** At each `_agg_goal` (=K) boundary,
-  `aggregate()`: `var = calculate_var(...)`; `var ≤ var_threshold` → **commit** (server-LR step, eval,
-  `data_id += 1`, `model_version += 1`, clear `cached_v`); else **roll back**, push grads to `cached_v`,
-  `iteration_per_data_id += 1`, **retry the same data_id**. `max_iter_per_data_id` force-commits despite
-  failed variance. So updates-per-`model_version` is a **random variable** of the gradient-variance
-  trajectory — **the `model_version` clock is not a fixed function of update count**, the central new
-  thing parity must reproduce. A round is the outer loop over data bins (`data_id`); `_round += 1` only
-  when `data_id == total_data_bins`.
-- **B.3 Dynamic K and C.** After each agg-goal cycle `DynamicKCController.step(metrics)` may change **K**
-  (`_agg_goal`) and **C** (concurrency) from observed metrics (var-pass ratio, eligible-ends). Parity
-  must reproduce the **K/C trajectory**, not a scalar.
-- **B.4 Eval per-variance-pass.** `eval_model()` runs on **every** committed data_id, not a fixed
-  schedule. The eval modeled-delay must be stamped (async_cifar10 dead-end: stale-eval `sct`
-  past-dating). FwdLLM eval is a forward pass (≈ train), so the eval delay model is closer to train than
-  async_cifar10's 20×-faster eval.
-
-> **Crux:** in async_cifar10 clock and commit count are loosely coupled; in FwdLLM the commit
-> (model-version) cadence is a *feedback function of gradient variance over the accumulated pool*. The
-> sim must reproduce not just **when** updates arrive (clock) but the **variance trajectory** gating
-> each commit. Variance is mode-invariant **iff** the contributing set+order+model-version of gradients
-> matches — reducing fwdllm parity back to clock+selection+ordering parity, plus a new
-> **variance-cadence** verification layer.
-
----
-
-## §C  Baseline matrix — **OPEN (blocking; user to supply)**
-
-fluxtune / fwdllm / fwdllm++ are **not** in code — they map to config knobs. Filling this is the one
-gate for the per-baseline plan (mirrors async_cifar10's felix/oort/refl/feddance source-of-truth).
-Candidate differentiating knobs:
-
-| Knob | Where | Meaning |
-|---|---|---|
-| `var_control` | hyperparameters | variance-gated dynamic-K on/off |
-| `var_threshold` | hyperparameters | commit gate |
-| `perturbation_sampling` | hyperparameters | forward-grad perturbation draw |
-| `select_perturbation_using_jvp` | hyperparameters | JVP-guided perturbation selection |
-| `is_async` | selector.kwargs | async grad loop vs sync barrier |
-| `selector.sort` | selector | `async_random` vs `async_oort` |
-| `dynamic_kc` | selector.kwargs | dynamic K/C vs static |
-| `max_iter_per_data_id` | hyperparameters | force-commit cap |
+## §B  How FwdLLM differs structurally
 
-**TO FILL (replace `?` with the mapping):**
+Full detail (the crux that makes the ladder applicable, and the variance-cadence rung layer it forces) is
+**PARITY.md §F.1**. In one line: fwdllm aggregates **gradients** (JVPs) not weights, its commit cadence is
+**endogenous** (variance-gated dynamic-K), and its progress axis is **`data_id`** (committed variance
+passes), not raw update count. Gradient *values* are mode-invariant given identical input+perturbation
+seed, so fwdllm parity reduces to clock+selection+ordering parity **plus** a new variance-cadence layer.
 
-| baseline | var_control | selector | dynamic_kc | perturbation / jvp-select | async | notes |
-|---|---|---|---|---|---|---|
-| **fluxtune** | ? | ? | ? | ? | ? | ? |
-| **fwdllm** | ? | ? | ? | ? | ? | ? |
-| **fwdllm++** | ? | ? | ? | ? | ? | ? |
-
-This mapping decides: whether Stage 4 (oort selection) runs, whether Stage 5 (sync barrier) runs, and
-the V1/V4 distributions (`max_iter_per_data_id`, `var_threshold` defaults). Parity is staged **one
-baseline at a time** (PARITY.md workflow rule 3).
+Concrete anchors (`flame/mode/horizontal/syncfl/fwdllm_aggregator.py`): `aggregate()` var gate +
+rollback/`cached_v` at each `_agg_goal` boundary; `total_data_bins=150` (`:271`); force-commit cap
+`_max_iter_per_data_id` (`:276`, config key `max_iterations_per_data_id`); `_reselect_each_iteration`
+(`:295`, per-iteration reselection for fwdllm++); sync path `_aggregate_grads_sync` (`:1354`).
 
 ---
 
-## §D  The parity ladder, adapted to FwdLLM
-
-Reuse the async_cifar10 ladder (PARITY.md §1–§2): same stages, role tags, tiers, dependency gating
-(lowest broken rung with sound inputs = ROOT).
-
-### D.1  Reused verbatim
-Stage 0 TC1/K10; Stage 1 P3/K1/K7; Stage 2 A1 (trivial under 100% avail) / A2; Stage 3 S3/4, A2c, and
-Sx/Sd/S2/S1 **only if the baseline uses oort selection** (skip for `async_random`); Stage 4 T2,
-per-phase timing, K6, T_mqtt; Stage 8 C1; Stage 9 budget/stop.
+## §C  Baseline matrix -- RESOLVED (from the landed launcher configs)
 
-### D.2  MODIFIED rungs (re-defined for variance-gated dynamic-K)
-| ID | async_cifar10 meaning | FwdLLM redefinition |
-|---|---|---|
-| **K3a** | K-th fastest async commit | advance of `model_version` **per committed data_id** (clock delta between successive **variance passes**) |
-| **K3b** | overhead residual ≈ 0 | same, measured on the **variance-pass** boundary |
-| **K2** | model versions / vsec | **committed data_ids / vsec** (throughput of *successful* variance passes) |
-| **U3** | version gap at commit | gap of each contributing gradient vs `model_version` at the cycle it lands — spread across **multiple iterations per data_id** |
-| **K8 / U2** | @ matched model_version | @ matched **data_id** (the meaningful progress axis) |
+Read from `expt_scripts/{fluxtune,fwdllm,fwdllm_plus}_n10_smoke.yaml`. Canonical copy + taxonomy mapping
+is **PARITY.md §F.2**; repeated here for the build plan.
 
-### D.3  NEW fwdllm-specific rungs (the variance-cadence layer — the prize)
-Append-only, with deps so the engine can localize.
+| baseline | sync/async | selector | agg | tracking_mode / avail | reselection | K (agg_goal) | dynamic_kc |
+|---|---|---|---|---|---|---|---|
+| **fluxtune** | async | `async_oort` | fedbuff (+server LR, JVP) | `client_notify` (3-tier, mobiperf_3st_50) | -- | 3 | disabled (fixed K/C) |
+| **fwdllm** | sync | `random` | fedavg | `default` (unaware) | per-round | 10 (=c; all selected required) | -- |
+| **fwdllm_plus** | sync | `random` | fedavg | `oracular` (`_metadata`, mobiperf_2st) | per-iteration (`reselect_each_iteration=True`) | 2 | -- |
 
-**Stage 6′ — Variance-gated aggregation cadence** (dep Stage 5 ordering + Stage 1 clock)
+**Availability-taxonomy mapping** (UNAVAILABILITY_DESIGN.md two axes):
+- **fwdllm** -- unaware at selection (`avail_select_filter=False`), reactive-90s in-flight
+  (`proactive_inflight_evict=False`).
+- **fwdllm_plus** -- aware at selection via `oracular` trace read (`avail_select_filter=True`),
+  reactive-90s in-flight.
+- **fluxtune** -- async, aware via `client_notify` (message-transport), reactive-90s in-flight.
+  `client_notify` is async_cifar10's **deferred Stage-H** tracking model -> **decision D1**.
 
-| ID | Check | Role/Tier | Isolates | Dep |
-|---|---|---|---|---|
-| **V1** | iterations-per-data_id dist (realized dynamic K) | MECHANISM/DIST | # accumulation cycles to pass variance ⇒ contributing set/order diverged | U5,U4 |
-| **V2** | per-cycle `var` trajectory (at each agg-goal) | MECHANISM/DIST | variance *signal* diverges with matched inputs ⇒ grad-pool composition/order differs | V1 |
-| **V3** | `cached_v` pool size over time | MECHANISM/DIAG | rollback/cache bookkeeping diverges | V1 |
-| **V4** | force-commit frequency (`max_iter_per_data_id` bypass rate) | MECHANISM/DIST | cap hit at a different rate ⇒ chronic variance divergence | V1 |
-| **V5** | variance-pass ratio per window | EMERGENT/DIST | rollup feeding DynamicKC | V1,V2 |
+This decides: Stage 3 oort rungs run **only** for fluxtune; Stage 5 sync-barrier rungs run for
+**fwdllm/fwdllm_plus**; V1/V4 distributions are shaped by each baseline's `max_iterations_per_data_id` /
+`var_threshold`. Parity is staged **one baseline at a time** (PARITY.md workflow rule).
 
-**Stage 3′ — Dynamic K/C trajectory** (dep Stage 3 selection + V5)
-
-| ID | Check | Role/Tier | Isolates | Dep |
-|---|---|---|---|---|
-| **DK1** | K (`_agg_goal`) trajectory | MECHANISM/DIST | DynamicKC sees different metrics ⇒ K diverges (feeds back into cadence) | V5 |
-| **DK2** | C (`dynamic_c`) trajectory | MECHANISM/DIST | concurrency target diverges | V5,S3/4 |
-| **DK3** | eligible-ends-count metric fed to policy | CONTROL/DIST | the policy *input* differs (fix input, not policy) | A2 |
+---
 
-**Stage 7′ — Forward-gradient quality**
+## §D  The parity ladder for fwdllm
 
-| ID | Check | Role/Tier | Isolates | Dep |
-|---|---|---|---|---|
-| **G1** | per-update grad/JVP norm or SNR dist | EMERGENT/DIST | grad *quality* diverges (should be ≈ mode-invariant; FAIL = perturbation seed/order leaked) | S2,T_gpu |
-| **G2** | grad_pool size at commit (realized contributions) | EMERGENT/DIST | rollup of V1×K | V1,DK1 |
+**Rung definitions live in PARITY.md §F** (modified rungs §F.3; variance-cadence / dynamic-K/C /
+forward-grad rungs §F.4). This section states only which rungs apply and how they gate.
 
-> **Decomposition example:** `K2`(throughput)✗ but `K3a`(per-pass advance)✓ → clock fine, commit count
-> diverged → walk to V1/V5. `V1`✗ + `V2`✓-given-matched-input → the *inputs* to variance differ → walk
-> to U5/S2. `V2`✗ with V1 inputs matched → a true grad-pool accumulation-order bug. Never fix K2/V5
-> directly (emergent) — localize the lowest variance-cadence rung with sound inputs.
+- **Reused verbatim** (PARITY.md §2): Stage 0 TC1/K10; Stage 1 P3/K1/K7; Stage 2 A1/A2 (+ A3 time-base
+  CONTROL, + A6/A7/A8 ground-truth once telemetry is ported); Stage 3 S3/4, A2c and the oort stack
+  (Sx/Sd/S2) **only for fluxtune**; Stage 4 T2, per-phase timing, K6, T_mqtt; Stage 8 C1; Stage 9 budget/stop.
+- **Modified** for variance-gated dynamic-K: K3a/K3b/K2/U3/K8/U2 -> PARITY.md §F.3 (all re-keyed to the
+  **variance-pass boundary** / committed **data_id**).
+- **New** -- the variance-cadence layer (the prize): V1-V5 (Stage 6'), DK1-DK3 (Stage 3'), G1-G2 (Stage 7')
+  -> PARITY.md §F.4. Localize down, never fix an EMERGENT rung directly; `var_threshold` /
+  `max_iterations_per_data_id` are config knobs, not parity levers.
+- **Availability** rungs (A1-A5, A6/A7/A8/K11, withheld_delivery, abandon_timeout, starvation_advance,
+  eligible_pool_reduction) are inherited from the async_cifar10 substrate and apply once §Stage-Avail
+  (below) wires the effect path + telemetry.
 
 ---
 
 ## §E  Staged implementation + validation
 
-Each stage states exit criteria + min run length (PARITY.md budget table). Land config-gated (flag-off
-⇒ byte-identical) + test-guarded.
+Each stage: config-gated (flag-off => byte-identical), test-guarded, exit criteria + min run length
+(PARITY.md budget table). Land one mechanism per run round. **Smoke (5 min) before any multi-hour run.**
 
-### Stage 0 — Telemetry coverage + real admissibility (gate)
-Port/confirm fwdllm emission for every field the ladder reads: `vclock_now`, `sim_completion_ts`/`sct`,
+### Stage 0 -- Telemetry coverage + real admissibility (gate)
+Confirm fwdllm emits every field the ladder reads: `vclock_now`, `sim_completion_ts`/`sct`,
 `model_version`, `data_id`, `iteration_per_data_id`, `var`, `var_threshold`, `_agg_goal`(K),
 `dynamic_c`(C), `agg_goal_count`, per-commit `train_duration`, `WALL_SEND_TS`/`WALL_RECV_TS`, grad/JVP
-norm. Implement **TC1** for fwdllm; **partition eval vs train commits** keyed on the variance-pass eval
-(async_cifar10 dead-end: eval commits polluting `agg_rounds` broke monotone/staleness). Run
-`validate_real`-equivalent admissibility (concurrency ≤ c, no double-dispatch, one-in-flight by
-construction). **Min:** 5–10 min smoke. **Exit:** TC1 all-present both modes; real admissible; report
-JSON with no SKIPs.
-
-### Stage 1 — Trainer sim path (modeled completion, no wall sleep)
-Add `simulated` mode to `FedSgdTrainer`: replace `_emulate_training_delay` (real `time.sleep`) with
+norm, **and `avail_change`/`agg_belief_change`/`send_gate_wait`** (§A.3 item 4). Implement **TC1** for
+fwdllm; **partition eval vs train commits** on the variance-pass eval (async_cifar10 dead-end: eval commits
+polluting `agg_rounds` broke monotone/staleness). Run `validate_real` admissibility. **Min:** 5-10 min
+smoke. **Exit:** TC1 all-present both modes; real admissible; report JSON no SKIPs.
+
+### Stage 1 -- Trainer sim path (modeled completion, no wall sleep)
+Add a `simulated` mode to `FedSgdTrainer`: replace `_emulate_training_delay` (real `time.sleep`) with
 stamping `_sim_completion_ts = sim_send_ts + max(real_gpu_s, modeled_budget_D) + sim_completion_leg_s`;
-send `SIM_COMPLETION_TS` + `SIM_CLIENT_TASK_TRAIN_DURATION_S` + `WALL_SEND_TS`/`WALL_RECV_TS` (client
-stamps for §S.dur). Stamp a **per-eval** `sct` (dead-end: reusing the last train `sct` past-dates every
-eval). Eval delay ≈ train (forward pass), **not** the 20× speedup — CONFIRM the factor per baseline.
-**Min:** 10 min. **Exit:** P3 (modeled D) matches; K6 advancing; T2 matched; no real `time.sleep` on
-the sim path.
-
-### Stage 2 — Drive the virtual clock from the grad loop (THE structural port)
-Replace the raw `channel.recv_fifo(...,1)` in `_aggregate_grads_async` with the inherited
+send `SIM_COMPLETION_TS` + `SIM_CLIENT_TASK_TRAIN_DURATION_S` + `WALL_SEND_TS`/`WALL_RECV_TS`. Stamp a
+**per-eval** `sct` (dead-end: reusing the last train `sct` past-dates every eval); eval delay ~= train
+(forward pass), **not** async_cifar10's 20x speedup -- **decision D4**. **Min:** 10 min. **Exit:** P3 matches;
+K6 advancing; T2 matched; no real `time.sleep` on the sim path.
+
+### Stage 2 -- Drive the virtual clock from the grad loop (THE structural port)
+Replace the raw `channel.recv_fifo(...,1)` in `_aggregate_grads_async` (`:693`) with the inherited
 **`_sim_recv_min`** path (sct-ordered reorder buffer + §3.drain) so a fast trainer's grad buffers as a
-future and grads are consumed in completion order. Wire **`_sim_hold_busy_slots`** (§3.resid) for
-one-in-flight-per-trainer. Note: fwdllm processes **one message per `_aggregate_grads_async` call**, so
-design the slot release on the **agg-goal boundary** (where `_per_agg_trainer_list` clears), NOT
-per-message — the hold/release points differ from asyncfl's batch `_aggregate_weights`. Keep
-`simCommitOverheadSeconds=0` (overhead on the vclock is a hard dead-end). **Risk:** a data_id can span
-**many** agg-goal cycles (rollback path) — the slot-hold and sct-buffer must survive rollbacks without
-leaking or double-committing a grad; over-instrument `inflight_residence` + per-cycle buffer occupancy.
-**Min:** 45 min. **Exit:** K1 monotone; K3a/K3b (per variance-pass) ≈ 0 residual; U5 inter-arrival;
-one-in-flight overlap ≈ real (target 0%); no past-dating (commit_gap ≈ 0).
-
-### Stage 3 — Variance-cadence parity (the fwdllm prize)
-Implement V1–V5, G1–G2 (§D.3). Likely root families (confirm via the lowest broken rung):
-- *Contributing-set/order divergence* (U5/S2 upstream) → V1 diverges → K2. Fix is upstream; V-rungs
-  only **localize**.
-- *Grad-pool accumulation order* (`cached_v` carry-over, `grad_pool.append` order) → V2 diverges with
-  matched inputs → a true sim bug in the accumulation bookkeeping.
-- *Force-commit rate* (V4) divergence → chronic variance divergence, not a separate bug.
-**Min:** 90 min – 2 h (variance-feedback-compounding, like the async clock residuals). **Exit:** V1/V2/V5
-PASS; K2 (committed-data_ids/vsec) PASS; DK1/DK2 track (if dynamic_kc on). **DynamicKC coupling:**
-validate **DK3** (policy *input*) before DK1/DK2 — a diverging input means fix the metric, not the
-policy (CONTROL-before-MECHANISM).
-
-### Stage 4 — Selection fidelity (only oort-selecting baselines)
-If any baseline uses `async_oort`, validate A2c/Sx/Sd/S2 + the §S.pacer/§S.temporal/§S.dur stack (all
-landed in `flame/selector/oort.py`). For `async_random` this stage is inert (S-rungs WARN/skip).
-**Min:** 45 min – 3 h (a selection-mix residual can surface late — refl K2 only at 3 h). **Exit:** A2c
-PASS, Sd binding real≈sim, no pacer ratchet.
-
-### Stage 5 — Sync-path parity (only if a baseline runs sync `_aggregate_grads_sync`)
-If any baseline is strict-sync, give the sync grad barrier the barrier-anchored visibility-lag
-treatment (§6.u6). Streaming (async) baselines commit each grad at its own sct → leave per-message
-correct. **Min:** 45 min. **Exit:** U6 barrier-anchored lag real≈sim; no per-message past-dating.
-
-### Stage 6 — Convergence sign-off
-C1 accuracy, C2 loss, K8/U2 terminal-state @ matched data_id. **Min:** full (3–4 h+). **Exit:** curves
+future and grads are consumed in completion order; wire **`_sim_hold_busy_slots`** (§3.resid) for
+one-in-flight-per-trainer. **fwdllm processes one message per `_aggregate_grads_async` call**, so key the
+slot release on the **agg-goal boundary** (where `_per_agg_trainer_list` clears), NOT per-message -- the
+hold/release points differ from asyncfl's batch `_aggregate_weights`. Keep `simCommitOverheadSeconds=0`
+(overhead on the vclock is a hard dead-end). **Risk:** a data_id can span **many** agg-goal cycles
+(rollback path) -- slot-hold + sct-buffer must survive rollbacks without leaking or double-committing a
+grad; over-instrument `inflight_residence` + per-cycle buffer occupancy. **Min:** 45 min. **Exit:** K1
+monotone; K3a/K3b (per variance-pass) ~= 0 residual; U5 inter-arrival; one-in-flight overlap ~= real;
+no past-dating (commit_gap ~= 0).
+
+### Stage Avail -- Wire unavailability into the grad loop (syn_20/50/mobiperf)
+Wire the inherited `ClientAvailability` effect path into fwdllm: send-time gate (real) /
+`delivery_ts = max(sct, next_avail)` buffering (sim); the two ledgers; per-baseline in-flight timing
+(reactive-90s for all three fwdllm baselines; no proactive-evict baseline here); starvation vclock-advance
+under scarcity; and per-baseline `avail_select_filter` (fwdllm off, fwdllm_plus/fluxtune on). Emit the
+availability telemetry (Stage 0) so A6/A7/A8/K11 run. **Interaction risk (decision D3):** a withheld/late
+grad meets the variance gate -- does it roll into `cached_v` on a rollback, and does a late grad against an
+old `model_version` inflate the variance signal? This is genuinely new vs async_cifar10 (which commits
+weights, not a variance-gated pool). **Min:** 45-90 min. **Exit:** A1-A5 + A6/A7/A8 PASS; withheld-then-
+delivered (not dropped); self-stops (`"stopping run"`, no `SIM_WALL_CEILING`); syn_0 byte-identical gate
+ON vs OFF.
+
+### Stage 3 -- Variance-cadence parity (the fwdllm prize)
+Implement V1-V5, G1-G2, DK1-DK3 (PARITY.md §F.4). Likely roots (confirm via the lowest broken rung):
+contributing-set/order divergence (U5/S2 upstream) -> V1 -> K2; grad-pool accumulation order
+(`cached_v` carry-over, `grad_pool.append` order) -> V2 with matched inputs = a true sim bug; force-commit
+rate (V4) = chronic variance divergence, not a separate bug. **DynamicKC coupling:** validate **DK3**
+(policy *input*) before DK1/DK2 (fluxtune leaves dynamic_kc off, so DK is inert there; relevant only if a
+baseline enables it). **Min:** 90 min - 2 h (variance-feedback-compounding). **Exit:** V1/V2/V5 PASS; K2
+(committed-data_ids/vsec) PASS; DK tracks if enabled.
+
+### Stage 4 -- Selection fidelity (fluxtune only, `async_oort`)
+Validate A2c/Sx/Sd/S2 + the §S.pacer/§S.temporal/§S.dur stack (all landed in `flame/selector/oort.py`).
+For the two `random`-selector baselines this stage is inert (S-rungs WARN/skip). **Min:** 45 min - 3 h (a
+selection-mix residual can surface late). **Exit:** A2c PASS, Sd binding real~=sim, no pacer ratchet.
+
+### Stage 5 -- Sync-path parity (fwdllm / fwdllm_plus, `_aggregate_grads_sync`)
+Give the sync grad barrier the barrier-anchored visibility-lag treatment (§6.u6). fluxtune streams (async),
+commits each grad at its own sct -> leave per-message correct. **Min:** 45 min. **Exit:** U6 barrier-
+anchored lag real~=sim; no per-message past-dating.
+
+### Stage 6 -- Convergence sign-off
+C1 accuracy, C2 loss, K8/U2 terminal-state @ matched **data_id**. **Min:** full (3-4 h+). **Exit:** curves
 within tolerance at matched data_id; K8/U2 rel within bar.
 
-### Per-stage discipline (from PARITY.md)
-Smoke (5 min) before any multi-hour run; one mechanism per run round when a fix could perturb another
-baseline; re-run **real** only when the real path changes (sim-only validates against the stored real
-dir); over-instrument first. Land config-gated + a pytest guard; run the fwdllm test subset + the shared
-selector/mode/sim/parity suites green before declaring a stage done.
-
 ---
 
-## §F  Key design decisions (precise)
-
+## §F  Key design decisions (open -- resolved at implementation)
+
+- **D1 -- tracking-mode strategy.** fluxtune's landed config uses `tracking_mode: client_notify`, which
+  UNAVAILABILITY_DESIGN.md treats as the **deferred Stage-H** message-transport model (async_cifar10 v1 is
+  all `trace_read`). Options: (a) implement `client_notify` first-class for fwdllm now (larger scope, but
+  it's baked into fluxtune's config and can't just be ignored), or (b) map fluxtune onto `trace_read` for a
+  v1 parity pass and treat `client_notify` as Stage H. **Lean (a)** -- fluxtune cannot run its intended
+  taxonomy without it. fwdllm_plus's `oracular` and fwdllm's unaware paths are already `trace_read`-shaped.
+- **D2 -- availability telemetry port.** The fwdllm trainer emits no `EVENT_AVAIL_CHANGE`; the aggregator
+  emits no `agg_belief_change`/`send_gate_wait`. All three builders exist in `flame/telemetry/events.py`
+  -- port emission (trainer state machine + aggregator belief hooks) so A6/A7/A8/K11 light up. Prereq for
+  Stage Avail's exit.
+- **D3 -- variance-cadence x withheld/late grads.** Does a withheld grad roll into `cached_v` on rollback?
+  Does a late grad against a stale `model_version` distort the `var` signal (and thus dynamic-K)? New to
+  fwdllm; over-instrument in Stage Avail before Stage 3.
+- **D4 -- eval-delay factor.** FedFwd eval is a forward pass (~= train cost), unlike async_cifar10's
+  ~20x-faster eval. Confirm the factor per baseline before Stage 1's per-eval `sct` stamp.
+
+### Locked principles (from async_cifar10, carried over)
 1. **Sim does real forward-grad compute, charges modeled time.** GPU runs the real JVP; the agg stamps
-   `sct = sim_send_ts + max(real_gpu_s, D) + leg`. Makes gradient values mode-invariant (§B.1).
+   `sct = sim_send_ts + max(real_gpu_s, D) + leg`. Makes gradient values mode-invariant.
    **Never** put overhead on the virtual clock (`vclock = max(vclock, sct)` only).
-2. **Progress axis is `data_id` (committed variance passes), not raw update count.** All throughput/
-   terminal rungs (K2, K8, U2) re-keyed to committed data_ids. Update count per data_id is the dynamic-K
-   random variable V1 validates — an output to match, not an input to assume.
-3. **Variance is the new emergent gate; localize it, never tune it.** A `var`/`var_pass_ratio`
-   divergence is *always* downstream of a contributing-set/order/accumulation divergence (V-rungs gate
-   on U5/S2/V1). Treat V5/DK1/DK2 as EMERGENT — walk down. `var_threshold` is a config knob, **not** a
-   parity lever.
-4. **Slot residence must survive variance rollbacks.** A data_id can span many agg-goal cycles, so
-   `_sim_hold_busy_slots` release keys on the **agg-goal boundary** (`_per_agg_trainer_list` clear), and
-   the sct reorder buffer must not strand a grad across a rollback. The fwdllm-specific extension of
-   §3.resid and the most likely subtle leak.
-5. **DynamicKC: validate the input before the policy.** DK3 (eligible-ends count, var-pass metrics fed
-   to `DynamicKCController.step`) is a CONTROL rung; a diverging *output* (DK1/DK2) with matched *input*
-   is the rare genuine policy bug, else fix the input. Controller is shared/baseline-agnostic — do not
-   fork it per baseline.
-6. **Real is the reference only after admissibility.** A real↔sim gap has **two** fix directions. The
-   §S.dur helper is already wired — keep it; if a selection-mix residual appears, check whether the
-   **real** input is the divergent side (PARITY.md: cleaning real can flip the divergence onto sim).
-7. **100% availability now, keep the seam.** `track_trainer_avail` stays wired but inert (`enabled:
-   False`); A1/A2 near-trivial. Do NOT delete the eligibility plumbing — unavailability is the next
-   workstream, following [UNAVAILABILITY_DESIGN.md](../async_cifar10/UNAVAILABILITY_DESIGN.md) (the
-   fwdllm side adds: which baselines are availability-aware, the variance-cadence interaction with a
-   withheld/late grad, and whether a withheld grad rolls into `cached_v`).
+2. **Progress axis is `data_id`** (committed variance passes). Update count per data_id is the dynamic-K
+   random variable V1 validates -- an output to match, not an input to assume.
+3. **Variance is an emergent gate; localize, never tune it.** V-rungs gate on U5/S2/V1. `var_threshold` is
+   a baseline-defining config knob.
+4. **Slot residence must survive variance rollbacks.** Release keys on the agg-goal boundary; the sct
+   reorder buffer must not strand a grad across a rollback (the fwdllm-specific extension of §3.resid).
+5. **DynamicKC: validate the input before the policy.** DK3 (CONTROL) before DK1/DK2 (MECHANISM). The
+   controller is shared/baseline-agnostic -- do not fork it per baseline.
+6. **Real is the reference only after admissibility.** A real<->sim gap has two fix directions; if a
+   selection-mix residual appears, check whether the **real** input is the divergent side.
+7. **syn_0 byte-identical gate OFF; unavailability config-gated.** Reuse the async_cifar10 flag axes and
+   the `simUnavailability` gate; do not delete eligibility plumbing.
 
 ---
 
 ## §G  Open questions / risks / dead-ends
 
 **Open (toward Stage 0):**
-- §C baseline→knob mapping (**blocking the per-baseline matrix**).
-- Eval-delay factor for fwdllm (forward pass ≈ train; what factor vs train budget?).
-- Which baselines are async vs sync (decides Stage 5).
-- Does any baseline use `async_oort` (decides Stage 4 scope) or all `async_random`?
-- `max_iter_per_data_id` / `var_threshold` defaults per baseline (drive V1/V4).
+- D1-D4 above.
+- Which real datasets/traces to use for the fwdllm reference runs (agnews H5 is the smoke default).
 
 **Risks specific to fwdllm:**
-- **Variance-cadence is feedback-compounding** — a tiny per-cycle grad-pool order difference compounds
-  into a different iterations-per-data_id (like the async clock residuals that surfaced only at 3 h).
-  Bin V1/V2 by run-fraction to separate a *constant* mix bias from a *compounding* feedback loop.
+- **Variance-cadence is feedback-compounding** -- a tiny per-cycle grad-pool order difference compounds into
+  a different iterations-per-data_id (like the async clock residuals that surfaced only at 3 h). Bin V1/V2
+  by run-fraction to separate a *constant* mix bias from a *compounding* feedback loop.
 - **`cached_v` carry-over** is stateful across cycles; a divergence looks like a variance bug but is
   bookkeeping (V3 DIAG localizes it).
-- **One-message-per-call grad loop** vs asyncfl's batch — slot-hold/release wiring is genuinely
-  different; do not copy async_cifar10's release points blindly.
+- **One-message-per-call grad loop** vs asyncfl's batch -- slot-hold/release wiring is genuinely different;
+  do not copy async_cifar10's release points blindly.
+- **Withheld grad x variance gate** (D3) -- a stale late grad may distort `var` and the dynamic-K decision.
 
-**Pre-emptive dead-ends (from PARITY.md):** overhead > 0 on the vclock; prediction-only gates that never
-block; tuning a scalar redispatch/overhead knob instead of fixing the mechanism; letting eval commits
-into the train/agg stream; expressing "busy" via the unavailable list. **fwdllm-new:** do **not** tune
-`var_threshold`/`max_iter_per_data_id` to force cadence parity — those are baseline-defining knobs; a
-cadence gap is an upstream set/order/clock divergence.
+**Pre-emptive dead-ends (from PARITY.md / UNAVAILABILITY_DESIGN.md):** overhead > 0 on the vclock;
+prediction-only gates that never block; tuning a scalar redispatch/overhead knob instead of fixing the
+mechanism; letting eval commits into the train/agg stream; expressing "busy" via the unavailable list.
+**fwdllm-new:** do **not** tune `var_threshold`/`max_iterations_per_data_id` to force cadence parity --
+those are baseline-defining knobs; a cadence gap is an upstream set/order/clock divergence.
 
 ---
 
 ## §H  Status
 
-*(empty — first entry after Stage 0 smoke. Record per-baseline run dirs, lowest broken rung, root
-hypothesis, score X/N, JSON path; keep the run-length budget keyed. One section, updated in place.)*
+*(empty -- first entry after Stage 0 smoke on the implementation branch. Record per-baseline run dirs,
+lowest broken rung, root hypothesis, score X/N, JSON path; keep the run-length budget keyed. One section,
+updated in place.)*
diff --git a/lib/python/flame/availability/__init__.py b/lib/python/flame/availability/__init__.py
index f6dd59dd2..4cf014595 100644
--- a/lib/python/flame/availability/__init__.py
+++ b/lib/python/flame/availability/__init__.py
@@ -2,7 +2,16 @@
 # SPDX-License-Identifier: Apache-2.0
 """Availability tracking modules."""
 
+from .client_availability import ClientAvailability
 from .feddance_predictor import FedDancePredictor
 from .refl_tracker import REFLAvailabilityTracker
+from .trace import load_trace, next_avail_after, state_at
 
-__all__ = ["REFLAvailabilityTracker", "FedDancePredictor"]
+__all__ = [
+    "ClientAvailability",
+    "FedDancePredictor",
+    "REFLAvailabilityTracker",
+    "load_trace",
+    "next_avail_after",
+    "state_at",
+]
diff --git a/lib/python/flame/availability/client_availability.py b/lib/python/flame/availability/client_availability.py
new file mode 100644
index 000000000..b221580b4
--- /dev/null
+++ b/lib/python/flame/availability/client_availability.py
@@ -0,0 +1,773 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""ClientAvailability — library-level oracular availability for all aggregators.
+
+Mixed into flame/mode/horizontal/syncfl/top_aggregator.TopAggregator (the
+common ancestor of the oort, asyncfl, syncfl, and fwdllm stacks). All four
+aggregators inherit read_trainer_unavailability, get_curr_unavail_trainers,
+_avail_now, _init_availability, and the dormant free_stalled_slot hook.
+
+This consolidates the three duplicated read_trainer_unavailability copies that
+previously lived in main_oort_sync_agg.py:173, main_asyncfl_agg.py:158, and
+fwdllm_aggregator.py:481, and the duplicated get_curr_unavail_trainers in
+main_oort_sync_agg.py:298 (which used wall-time in sim — now corrected to
+use _vclock.now via _avail_now()).
+
+Stage A: substrate only — no behavior change when sim_unavailability=False
+(the default). _init_availability sets trainer_event_dict=None when the gate
+is off, preserving byte-identical output on syn_0 runs.
+Stage C will activate free_stalled_slot and wire the pending_withheld ledger.
+"""
+
+import logging
+import math
+import time
+from typing import Optional
+
+from flame import telemetry
+from flame.availability.trace import load_trace, next_avail_after, state_at
+from flame.availability.trace import (
+    read_trainer_unavailability as _read_trainer_unavailability,
+)
+from flame.config import TrainerAvailState
+from flame.mode.message import MessageType
+from flame.selector.properties import PROP_AVL_STATE, PROP_SIM_SEND_TS
+from flame.telemetry.events import (
+    build_abandon_timeout,
+    build_agg_belief_change,
+    build_withheld_delivery,
+)
+
+logger = logging.getLogger(__name__)
+
+_AVL_STATES = frozenset(
+    {TrainerAvailState.AVL_TRAIN, TrainerAvailState.AVL_EVAL}
+)
+
+# Re-clock of the selector's wall-based abandon (SEND_TIMEOUT_WAIT_S) onto the
+# vclock. Heuristic basis (PARITY.md / design §1): train takes ≤60s, so an
+# in-flight trainer dispatched > 90 vclock-seconds ago is assumed offline.
+_AVAIL_ABANDON_TIMEOUT_S = 90.0
+
+
+class ClientAvailability:
+    """Oracular availability substrate for TopAggregator subclasses.
+
+    Depends on attributes set by syncfl TopAggregator.internal_init():
+        self.simulated       (bool)
+        self._vclock         (VirtualClock)
+        self.agg_start_time_ts  (float, epoch seconds)
+        self.config          (Config)
+    These are all present before initialize() runs, so _init_availability
+    may be called from internal_init() or initialize().
+    """
+
+    # ------------------------------------------------------------------
+    # Initialization
+    # ------------------------------------------------------------------
+
+    def _init_availability(self, config) -> None:
+        """Populate trainer_event_dict from config; no-op when gate is off.
+
+        Master gate: sim_unavailability (default False). Also accepts the
+        legacy track_trainer_avail["enabled"]=True path so existing configs
+        keep working without adding the new flag.
+
+        Sets:
+            self.trainer_event_dict     — dict[task_id → SortedDict] or None
+            self.avail_select_filter    — bool (exclude UN_AVL from selection pool)
+            self.proactive_inflight_evict — bool (Stage D proactive boundary eviction)
+            self.pending_withheld       — dict[end → delivery_ts] (Stage C)
+        """
+        hp = config.hyperparameters
+        self.trainer_event_dict: Optional[dict] = None
+        # avail_select_filter: whether UN_AVL trainers are excluded from the
+        # selection pool (get_curr_task_ineligible_trainers). True for aware
+        # baselines (felix/oort_star/refl/feddance); False for unaware (oort/fedbuff).
+        self.avail_select_filter: bool = bool(
+            getattr(hp, "avail_select_filter", True)
+        )
+        # proactive_inflight_evict: whether in-flight slots are freed at the next
+        # selection boundary when the trace shows UN_AVL (felix only).
+        # NOTE: `_legacy_aware` fallback is dead in practice -- the pydantic
+        # field always exists (default=None), so getattr never falls back to
+        # it; kept as the correct safe default if that ever changes.
+        _legacy_aware = bool(getattr(hp, "availability_aware", False))
+        self.proactive_inflight_evict: bool = bool(
+            getattr(hp, "proactive_inflight_evict", _legacy_aware)
+        )
+        self.pending_withheld: dict = {}
+        # C.2 send-time withhold ledgers (shared by asyncfl + oort commit loops):
+        #   _sim_withheld_payload   end -> (orig_sct, (msg, metadata)) held update
+        #   _sim_withheld_delivering end -> (orig_sct, delivery_ts) being re-injected
+        # Initialized here (before the gate check) so the commit-loop helpers can
+        # reference them unconditionally; they stay empty when the gate is off.
+        if not hasattr(self, "_sim_withheld_payload"):
+            self._sim_withheld_payload: dict = {}
+        if not hasattr(self, "_sim_withheld_delivering"):
+            self._sim_withheld_delivering: dict = {}
+
+        sim_unavail = bool(getattr(hp, "sim_unavailability", False))
+        track = getattr(hp, "track_trainer_avail", None) or {}
+        legacy_enabled = str(track.get("enabled", "False")).strip().lower() == "true"
+
+        if not sim_unavail and not legacy_enabled:
+            return
+
+        if sim_unavail:
+            client_notify = getattr(hp, "client_notify", None) or {}
+            trace_name = (
+                client_notify.get("trace")
+                or getattr(hp, "availability_trace", None)
+                or track.get("trace")
+            )
+        else:
+            # Legacy path: only activate for ORACULAR type
+            if str(track.get("type", "")).upper() != "ORACULAR":
+                return
+            trace_name = track.get("trace")
+
+        if not trace_name:
+            logger.warning("[AVAIL] availability enabled but no trace name configured")
+            return
+
+        trace_dir = getattr(hp, "availability_trace_dir", None)
+        self.trainer_event_dict = self.read_trainer_unavailability(
+            trace=trace_name, base_dir=trace_dir
+        )
+        # D.2 guard: does this trace ever produce AVL_EVAL anywhere, for any
+        # trainer? syn_0/syn_20/syn_50 are 2-state (AVL_TRAIN/UN_AVL only) —
+        # "the AVL_TRAIN<->AVL_EVAL split a 2-state trace collapses" (§1 Trace
+        # representation). Computed once here, not per-call (would be an
+        # O(trainers) scan of every SortedDict on every selection boundary).
+        self._trace_has_avl_eval: bool = bool(self.trainer_event_dict) and any(
+            TrainerAvailState.AVL_EVAL in trace.values()
+            for trace in self.trainer_event_dict.values()
+        )
+
+    # ------------------------------------------------------------------
+    # Time source — single call site for "what time is it on the trace timeline"
+    # ------------------------------------------------------------------
+
+    def _avail_now(self) -> float:
+        """Current time on the availability timeline.
+
+        sim:  self._vclock.now  (sim-seconds since experiment start)
+        real: wall-elapsed since agg_start_time_ts
+
+        Never uses a per-trainer frozen clock (_sim_send_ts) — see PARITY.md §S.dur
+        and the REFL HIGH-1 frozen-clock root cause.
+        """
+        if getattr(self, "simulated", False):
+            return float(self._vclock.now)
+        return time.time() - self.agg_start_time_ts
+
+    # ------------------------------------------------------------------
+    # Trace loading (replaces three duplicated copies)
+    # ------------------------------------------------------------------
+
+    def read_trainer_unavailability(
+        self,
+        trace: Optional[str] = None,
+        base_dir: Optional[str] = None,
+    ) -> Optional[dict]:
+        """Build task_id → SortedDict[ts_s → state_str] from the canonical store.
+
+        Thin wrapper -- the implementation is a free function in
+        flame.availability.trace so scripts/parity/ground_truth.py can call
+        it without instantiating this mixin. Kept here for existing callers
+        (self.read_trainer_unavailability(...) in _init_availability).
+        """
+        return _read_trainer_unavailability(trace, base_dir=base_dir)
+
+    # ------------------------------------------------------------------
+    # Oracular selection gate
+    # ------------------------------------------------------------------
+
+    def get_curr_unavail_trainers(self) -> list:
+        """Trainers in UN_AVL state per trace-read at _avail_now().
+
+        Returns [] when trainer_event_dict is None (gate off) or
+        avail_select_filter is False (unaware baselines: oort/fedbuff).
+        Byte-identical to today's behavior when sim_unavailability=False.
+
+        Replaces the inlined bisect_right loop formerly duplicated in:
+            syncfl/top_aggregator.py:1163
+            main_oort_sync_agg.py:298  (wall-time bug now corrected)
+        """
+        if self.trainer_event_dict is None:
+            return []
+        if not getattr(self, "avail_select_filter", True):
+            return []
+
+        now = self._avail_now()
+        unavail = [
+            tid
+            for tid, trace in self.trainer_event_dict.items()
+            if state_at(trace, now) == TrainerAvailState.UN_AVL
+        ]
+        logger.info(
+            f"[TRACE_READ] unavail={len(unavail)}/{len(self.trainer_event_dict)} "
+            f"@ t={now:.1f}s"
+        )
+        return unavail
+
+    def get_curr_task_ineligible_trainers(self, task: str) -> list:
+        """D.2: UN_AVL + task-type-ineligible trainers per the trace-read.
+
+        Extends get_curr_unavail_trainers with the task-type partition:
+        AVL_TRAIN-only trainers are excluded from "eval" dispatch and vice
+        versa; UN_AVL is excluded from both. Returns [] when the gate is off
+        or avail_select_filter is False. The `_trace_has_avl_eval` guard is
+        load-bearing: without it, a 2-state trace (nobody ever AVL_EVAL)
+        makes "eval"'s eligible pool permanently empty, and an empty pool fed
+        into the selector's shared-`selected_ends` cleanup (Challenge 13)
+        wipes out train's in-flight tracking too — found via a real felix
+        syn_0 hang (zero AGG_RECV_WEIGHTS despite all trainers sending).
+        """
+        if self.trainer_event_dict is None:
+            return []
+        if not getattr(self, "avail_select_filter", True):
+            return []
+        has_eval = getattr(self, "_trace_has_avl_eval", False)
+        excluded_state = (
+            TrainerAvailState.AVL_EVAL if task == "train"
+            else TrainerAvailState.AVL_TRAIN if (task == "eval" and has_eval)
+            else None
+        )
+        now = self._avail_now()
+        ineligible = [
+            tid
+            for tid, trace in self.trainer_event_dict.items()
+            if state_at(trace, now) == TrainerAvailState.UN_AVL
+            or (excluded_state is not None and state_at(trace, now) == excluded_state)
+        ]
+        logger.info(
+            f"[TRACE_READ] task={task!r} ineligible="
+            f"{len(ineligible)}/{len(self.trainer_event_dict)} @ t={now:.1f}s"
+        )
+        return ineligible
+
+    def _avail_stamp_end_states(self, channel) -> None:
+        """C.6.1 follow-up: write each known end's CURRENT oracular state onto
+        PROP_AVL_STATE before selection, so emit_selection's avail_composition /
+        per_trainer["avl_state"] reflect reality instead of staying all-UNKNOWN.
+
+        PROP_AVL_STATE (flame.selector.properties) was never written anywhere in
+        the v1 oracular path — only the legacy client_notify push (channel.py
+        update_state -> PROP_END_AVL_STATE, a DIFFERENT property, off in v1) set
+        an end's availability property. Without this, avail_composition's
+        `end.get_property(PROP_AVL_STATE)` read None for every end, every round.
+
+        Stamps EVERY known end (channel._ends), not just the eligible/candidate
+        subset — this is what makes an in-flight trainer D.1/C.3 just evicted
+        show up as UN_AVL in the very next selection's telemetry, instead of
+        being structurally invisible to it. No-op when the gate is off
+        (trainer_event_dict is None) ⇒ byte-identical at sim_unavailability=False.
+        """
+        if self.trainer_event_dict is None:
+            return
+        now = self._avail_now()
+        for end_id in list(channel._ends.keys()):
+            trace = self.trainer_event_dict.get(end_id)
+            state = state_at(trace, now) if trace else TrainerAvailState.AVL_TRAIN
+            channel.set_end_property(end_id, PROP_AVL_STATE, state)
+        # No separate agg_belief_change emission for the "selection" checkpoint:
+        # PROP_AVL_STATE (stamped above) is already read by emit_selection into
+        # per_trainer[end]["avl_state"] on every selection event, so A7's
+        # selection score reads that directly. Only "commit" (below) is new.
+
+    # ------------------------------------------------------------------
+    # Aggregator belief tracking (Batch 3 T3.3) — mechanism-agnostic hook
+    # ------------------------------------------------------------------
+
+    def _record_avail_belief(
+        self, end: str, state: str, *, observed_at: float,
+        checkpoint: str, source: str = "trace_read",
+    ) -> None:
+        """Persist the aggregator's BELIEF about `end`'s availability state.
+
+        Tagged by ``checkpoint`` ("selection" | "commit") and knowledge-source
+        ``source`` (the mechanism populating this belief — "trace_read" today,
+        "client_notify"/"predictive" later per Stage H). Mechanism-agnostic by
+        design: a future populator calls this with a different `source`, no
+        telemetry/checker/plot change needed. Emits `agg_belief_change`;
+        no-op when telemetry is disabled.
+        """
+        if not telemetry.is_enabled():
+            return
+        ev, f = build_agg_belief_change(
+            round_num=getattr(self, "_round", -1), end_id=end, state=str(state),
+            observed_at=float(observed_at), checkpoint=checkpoint, source=source,
+        )
+        telemetry.emit(ev, **f)
+
+    def _record_commit_belief(self, end: str, sct: Optional[float] = None) -> None:
+        """T3.3 commit checkpoint: record the trace-read belief at an update's
+        completion instant — one shared call site for both modes and all
+        three aggregator stacks (asyncfl/oort/syncfl), rather than each
+        re-deriving `state_at()` independently.
+
+        sim: called from `_sim_withhold_if_unavail`, so this reads the exact
+        state that gate's own withhold decision is based on. real: called
+        from each stack's real receive loop; the aggregator never gates on
+        this in real mode (enforcement is trainer-side, T3.1a/T3.1b's
+        send-gate) — recording it anyway gives A7 a same-instant
+        ground-truth comparison point for every baseline, including unaware
+        ones (oort/fedbuff) that don't filter at selection.
+
+        No-op when the gate is off (trainer_event_dict is None), or on a
+        bare/partially-initialized aggregator that never ran
+        _init_availability (mirrors _sim_withhold_if_unavail's own guard, so
+        this is safe to call from any real-mode commit loop unconditionally),
+        or when `end` has no trace entry (e.g. a registry mismatch).
+        """
+        trainer_event_dict = getattr(self, "trainer_event_dict", None)
+        if trainer_event_dict is None:
+            return
+        trace = trainer_event_dict.get(end)
+        if trace is None:
+            return
+        now = float(sct) if sct is not None else self._avail_now()
+        state = state_at(trace, now)
+        self._record_avail_belief(end, state.value, observed_at=now, checkpoint="commit")
+
+    # ------------------------------------------------------------------
+    # Delivery ledger (Stage C) — withheld update bookkeeping
+    # ------------------------------------------------------------------
+    #
+    # Two ledgers, never one (Challenge 4 / invariant 1):
+    #   * slot ledger    — in-flight count; freed here (free_stalled_slot).
+    #   * delivery ledger — pending_withheld[end] = delivery_ts; the completed
+    #                       update is HELD, not discarded, and committed later
+    #                       (stale) by the live commit loop.
+    # The same effect path serves all three triggers (90s vclock abandon, aware
+    # boundary eviction, and the future avl_* message) — only the trigger differs.
+
+    def compute_delivery_ts(self, end: str, sct: float) -> float:
+        """When a withheld update from `end` becomes deliverable.
+
+        The earliest time >= sct at which the trainer is AVL_* again: a
+        completed-but-withheld update cannot deliver before it finished
+        computing (`sct`) nor while the trainer is unreachable. If the trainer
+        is already available at `sct` (it recovered before completing, or never
+        went down) delivery is immediate (= sct); otherwise it waits for the
+        next AVL_* window. Returns math.inf when the trace never recovers — the
+        caller must guard (Challenge 10); the update is undeliverable in-window.
+        """
+        if self.trainer_event_dict is None:
+            return float(sct)
+        trace = self.trainer_event_dict.get(end)
+        if not trace:
+            return float(sct)
+        ref = float(sct)
+        if state_at(trace, ref) in _AVL_STATES:
+            return ref
+        nxt = next_avail_after(trace, ref)
+        if nxt == math.inf:
+            return math.inf
+        return max(ref, float(nxt))
+
+    def free_stalled_slot(
+        self, channel, end: str, *, reason: str, sct: Optional[float] = None
+    ) -> Optional[float]:
+        """Free an in-flight slot and register its pending withheld delivery.
+
+        Triggered by (a) the 90s vclock abandon for everyone (C.3) and (b) the
+        aware boundary eviction for availability_aware baselines (Stage D); Stage H
+        adds an avl_* message trigger without changing this effect logic — the
+        abstraction exists for exactly that swap.
+
+        1. Remove `end` from the selector slot ledger (selected_ends / all_selected).
+        2. Compute delivery_ts = compute_delivery_ts(end, sct) (delivery ledger).
+        3. Register pending_withheld[end] = delivery_ts.
+
+        No-op (returns None) when the gate is off (trainer_event_dict is None),
+        preserving byte-identity. Returns the registered delivery_ts otherwise.
+        """
+        if self.trainer_event_dict is None:
+            logger.debug(
+                f"[AVAIL] free_stalled_slot({end!r}) — gate off, no-op"
+            )
+            return None
+
+        # 1. Slot ledger: release the concurrency slot so a replacement is
+        #    selectable. Mirrors the abandon path's removal (random.py:215).
+        #    Robust to BOTH selector shapes: asyncfl (fedbuff/async_oort/
+        #    async_random) keep selected_ends as a dict keyed by requester plus an
+        #    all_selected dict; oort/refl/feddance keep selected_ends as a flat set
+        #    and have no all_selected. Drop `end` from whichever is present.
+        self._avail_free_slot_ledger(channel, end)
+        # Drop it from the asyncfl gate's in-flight tracker too (no-op on oort,
+        # which tracks in-flight purely via selected_ends) — "free the slot" is one
+        # effect across both stacks.
+        self._avail_drop_inflight(end)
+
+        # 2/3. Delivery ledger: hold the completed update until delivery_ts.
+        if sct is None:
+            sct = self._avail_now()
+        delivery_ts = self.compute_delivery_ts(end, sct)
+        self.pending_withheld[end] = delivery_ts
+        logger.info(
+            f"[AVAIL] free_stalled_slot({end!r}, reason={reason!r}) "
+            f"sct={float(sct):.1f} delivery_ts={delivery_ts:.1f}"
+        )
+        return delivery_ts
+
+    def withheld_held_ends(self, now: Optional[float] = None) -> set:
+        """Ends whose withheld update has NOT yet reached its delivery_ts.
+
+        These must stay out of the eligible pool (invariant 2: a still-down
+        trainer is never re-selected) until vclock >= delivery_ts — the §4.5
+        residence exclusion extended from `sct` to `delivery_ts`. Unioned into
+        the unavailable list by the selection driver.
+        """
+        if not self.pending_withheld:
+            return set()
+        if now is None:
+            now = self._avail_now()
+        return {end for end, dts in self.pending_withheld.items() if dts > now}
+
+    def ready_withheld(self, now: Optional[float] = None) -> list:
+        """Withheld ends due for delivery (delivery_ts <= now), commit order.
+
+        Ordered by (delivery_ts, end_id) so the late stale commits replay
+        deterministically (Challenge 1/6 — past-dating is avoided because a
+        withheld update commits at delivery_ts > sct, never at sct).
+        """
+        if not self.pending_withheld:
+            return []
+        if now is None:
+            now = self._avail_now()
+        due = [
+            (end, dts) for end, dts in self.pending_withheld.items() if dts <= now
+        ]
+        due.sort(key=lambda kv: (kv[1], str(kv[0])))
+        return due
+
+    def commit_withheld(self, end: str) -> Optional[float]:
+        """Pop `end` from the delivery ledger once its late update has committed."""
+        return self.pending_withheld.pop(end, None)
+
+    # ------------------------------------------------------------------
+    # Slot-ledger helpers (robust to both selector shapes)
+    # ------------------------------------------------------------------
+
+    def _avail_free_slot_ledger(self, channel, end: str) -> None:
+        """Drop `end` from the selector slot ledger + reset its end state.
+
+        asyncfl selectors keep selected_ends as dict[requester -> set] + an
+        all_selected dict; oort/refl/feddance keep selected_ends as a flat set
+        and have no all_selected. Handle whichever is present.
+        """
+        sel = getattr(channel, "_selector", None)
+        if sel is not None:
+            all_selected = getattr(sel, "all_selected", None)
+            if isinstance(all_selected, dict):
+                all_selected.pop(end, None)
+            selected_ends = getattr(sel, "selected_ends", None)
+            if isinstance(selected_ends, dict):
+                requester = getattr(sel, "requester", None)
+                if requester in selected_ends:
+                    selected_ends[requester].discard(end)
+            elif isinstance(selected_ends, set):
+                selected_ends.discard(end)
+        if channel.has(end):
+            from flame.end import KEY_END_STATE, VAL_END_STATE_NONE
+
+            channel._ends[end].set_property(KEY_END_STATE, VAL_END_STATE_NONE)
+
+    def _avail_drop_inflight(self, end: str) -> None:
+        """Remove `end` from the asyncfl gate's in-flight tracker (no-op on oort)."""
+        ie = getattr(self, "_sim_inflight_expected", None)
+        if isinstance(ie, dict):
+            ie.pop(end, None)
+
+    def _avail_inflight_ends(self, channel) -> set:
+        """In-flight (slot-ledger) ends, generic over both selector shapes."""
+        sel = getattr(channel, "_selector", None)
+        if sel is None:
+            return set()
+        se = getattr(sel, "selected_ends", None)
+        if isinstance(se, dict):
+            out: set = set()
+            for v in se.values():
+                out |= set(v)
+            return out
+        if isinstance(se, (set, list, tuple)):
+            return set(se)
+        return set()
+
+    # ------------------------------------------------------------------
+    # Shared commit-loop wiring (C.2 / C.3) — one logic for asyncfl + oort
+    # ------------------------------------------------------------------
+    #
+    # Both stacks own a different sim commit loop (asyncfl _sim_recv_min's single
+    # pop site; oort _sim_drain_buffer's generator pop loop), but the send-gate /
+    # late-recommit / vclock-abandon EFFECT is identical, so it lives here and each
+    # loop just calls in. Depends only on self._sim_buffer + the ledgers; never on
+    # a stack-specific attribute (the gate tracker is reached via the guarded
+    # _avail_drop_inflight hook). Off ⇒ pending_withheld stays empty ⇒ no-op.
+
+    def _sim_reinject_ready_withheld(self) -> None:
+        """C.2: re-inject withheld updates whose delivery_ts has arrived.
+
+        Call before each pop. For every ledger entry due at the current vclock,
+        re-add the held payload to the reorder buffer at delivery_ts so it
+        commits stale through the normal path, then pop the ledger. A
+        slot-only entry (registered at eviction time, before the update
+        physically completed) carries no payload yet — it STAYS registered
+        rather than being dropped; once the payload arrives, `_sim_withhold_
+        if_unavail` recognizes it's still in `pending_withheld`, stashes it,
+        and bumps `delivery_ts` to the real completion time so the next call
+        here delivers it. No-op when the ledger is empty.
+        """
+        if not getattr(self, "pending_withheld", None):
+            return
+        buf = getattr(self, "_sim_buffer", None)
+        if buf is None:
+            return
+        for end, dts in self.ready_withheld(self._avail_now()):
+            payload = self._sim_withheld_payload.pop(end, None)
+            if payload is None:
+                continue  # no payload yet; stays registered until it arrives
+            self.commit_withheld(end)
+            orig_sct, msgmd = payload
+            buf.add(end, float(dts), msgmd)
+            self._sim_withheld_delivering[end] = (float(orig_sct), float(dts))
+            logger.info(
+                f"[WITHHELD_REINJECT] end={str(end)[-4:]} "
+                f"sct={float(orig_sct):.1f} delivery_ts={float(dts):.1f}"
+            )
+
+    def _sim_withhold_if_unavail(self, channel, end, sct, msgmd) -> bool:
+        """Per-update send-gate: True if this completed update is HELD, else False.
+
+        The single-update primitive both commit loops share. When True the caller
+        must skip the update — it has been removed from the buffer/slot accounting
+        (held in the delivery ledger, delivered stale at delivery_ts). When False
+        the update is committable now (trainer available at completion, or gate
+        off). The caller applies any stack-specific gate (oort's still-computing
+        carry-over) BEFORE this — a still-computing future-sct straggler has not
+        reached its send-gate yet (Challenge 7), so carry-over wins.
+
+        Returns False unchanged when sim_unavailability is off (compute_delivery_ts
+        ⇒ sct), preserving byte-identity.
+        """
+        # Gate off (or a bare aggregator that never ran _init_availability): the
+        # update is always committable and no ledger is touched. Keeps the shared
+        # primitive safe to call from any partially-initialized commit loop.
+        if getattr(self, "trainer_event_dict", None) is None:
+            return False
+        # T3.3 commit-checkpoint belief: read once here, covering both branches
+        # below (fresh commit and re-registered/re-stashed) with one call.
+        self._record_commit_belief(end, sct)
+        # invariant 1: never re-register / double-count an end whose slot was
+        # already freed (C.3 abandon). Its arrived payload is stashed so the
+        # reinject delivers it at the registered delivery_ts.
+        if end in self.pending_withheld:
+            self._sim_withheld_payload[end] = (float(sct), msgmd)
+            self._avail_drop_inflight(end)
+            # delivery_ts was an ESTIMATE made at eviction time (before this
+            # update finished computing); bump to the real completion-based
+            # value if later -- never earlier (invariant 2: never release a
+            # still-down trainer before its registered window).
+            self.pending_withheld[end] = max(
+                self.pending_withheld[end], self.compute_delivery_ts(end, float(sct))
+            )
+            return True
+        dts = self.compute_delivery_ts(end, sct)
+        if dts <= sct:
+            return False  # available at completion (or gate off) — commit now
+        # withhold: trainer is UN_AVL at sct; hold the completed update.
+        if dts == math.inf:
+            # trace never recovers in-window: the update is undeliverable.
+            # free_stalled_slot still registers the ledger (end stays excluded);
+            # drop the payload (acceptable v1 edge, Challenge 10).
+            logger.info(
+                f"[WITHHELD_LOST] end={str(end)[-4:]} sct={float(sct):.1f} "
+                f"trace never recovers"
+            )
+        else:
+            self._sim_withheld_payload[end] = (float(sct), msgmd)
+        self.free_stalled_slot(
+            channel, end, reason="send_gate_withhold", sct=float(sct)
+        )
+        return True
+
+    def _sim_pop_committable(self, channel):
+        """C.2 (asyncfl): pop the smallest buffered update that is committable now.
+
+        Loops over _sim_withhold_if_unavail, skipping send-gated updates and
+        popping the next-smallest committable one. Returns (end, sct, (msg,
+        metadata)) or None (buffer drained). The vclock is NOT advanced for a
+        withheld pop — only the committed update drives the clock.
+
+        Off (or trainer available at sct) ⇒ a single pop identical to the prior
+        pop_min(); reinject a no-op. Byte-identical when sim_unavailability is off.
+        """
+        buf = self._sim_buffer
+        while True:
+            popped = buf.pop_min()
+            if popped is None:
+                return None
+            end, sct, msgmd = popped
+            if self._sim_withhold_if_unavail(channel, end, sct, msgmd):
+                continue
+            return popped
+
+    def _sim_take_withheld_delivering(self, end: str) -> Optional[tuple]:
+        """Pop (orig_sct, delivery_ts) if `end`'s commit is a late withheld delivery.
+
+        The commit body calls this to recognize a re-injected stale delivery (vs a
+        fresh/straggler commit) so it can emit the withheld_delivery rung and tag
+        the "withheld" past-dating bucket. Returns None for an ordinary commit.
+        """
+        d = getattr(self, "_sim_withheld_delivering", None)
+        if not d:
+            return None
+        return d.pop(end, None)
+
+    def _emit_withheld_delivery(self, end, msg, orig_sct, delivery_ts) -> None:
+        """Emit the withheld_delivery rung for a late stale commit (best-effort).
+
+        Stamps ``actual_commit_ts`` via ``_avail_now()`` — call this AFTER
+        advancing the clock (``_advance_sim_clock``) for this update, kept
+        as one uniform rule across all three stacks (see UNAVAILABILITY_
+        DESIGN.md's T3.5 for why syncfl/oort's drain loops were reordered to
+        match asyncfl, despite it being a provable no-op there today).
+        """
+        if not telemetry.is_enabled():
+            return
+        mv = msg.get(MessageType.MODEL_VERSION) if isinstance(msg, dict) else None
+        ev, f = build_withheld_delivery(
+            round_num=self._round, end_id=end,
+            sct=float(orig_sct), delivery_ts=float(delivery_ts),
+            staleness=(self._round - int(mv)) if mv is not None else None,
+            accepted=True, time_mode="sim",
+            actual_commit_ts=self._avail_now(),
+        )
+        telemetry.emit(ev, **f)
+
+    def _sim_abandon_stalled(self, channel) -> None:
+        """C.3: free in-flight slots stalled past the 90s vclock deadline.
+
+        Re-clocks the selector's wall-based abandon (inert in sim) onto the vclock.
+        A trainer dispatched > 90 vclock-seconds ago whose update has neither
+        buffered nor committed is assumed offline: free its slot (a replacement
+        becomes selectable) and register the delivery ledger. If its update later
+        physically arrives it is reconciled by _sim_pop_committable (payload stash)
+        / _sim_reinject_ready_withheld.
+
+        Slot ledger ⊥ delivery ledger (Challenge 4): the slot is freed here, the
+        completed update is NOT discarded — it still commits (stale) and is
+        accept/reject-gated by the baseline's existing staleness rule. No-op when
+        the gate is off (trainer_event_dict is None) ⇒ byte-identical.
+        """
+        if getattr(self, "trainer_event_dict", None) is None:
+            return
+        inflight = self._avail_inflight_ends(channel)
+        if not inflight:
+            return
+        now = self._avail_now()
+        buf = getattr(self, "_sim_buffer", None)
+        committed = getattr(self, "_sim_committed", set())
+        for end in list(inflight):
+            if buf is not None and buf.has(end):
+                continue  # already arrived — not stalled
+            if end in committed or end in self.pending_withheld:
+                continue  # invariant 1: already committed / abandoned
+            sst = channel.get_end_property(end, PROP_SIM_SEND_TS)
+            if sst is None:
+                continue
+            if now - float(sst) <= _AVAIL_ABANDON_TIMEOUT_S:
+                continue
+            self.free_stalled_slot(
+                channel, end, reason="abandon_90s_vclock", sct=now
+            )
+            logger.info(
+                f"[ABANDON_90S] end={str(end)[-4:]} sim_send_ts={float(sst):.1f} "
+                f"vclock={now:.1f} age={now - float(sst):.1f}s"
+            )
+            if telemetry.is_enabled():
+                ev, f = build_abandon_timeout(
+                    round_num=getattr(self, "_round", -1), end_id=end,
+                    sim_send_ts=float(sst), vclock_now=now, time_mode="sim",
+                    reason="abandon_90s_vclock",
+                )
+                telemetry.emit(ev, **f)
+
+    def _sim_evict_unavail_inflight(self, channel) -> None:
+        """D.1: Proactively free in-flight slots for trainers now showing UN_AVL.
+
+        For availability_aware baselines the oracular trace read at the selection
+        boundary is authoritative — no need to wait for the 90s vclock deadline
+        (C.3). A trainer that transitioned to UN_AVL since it was dispatched has
+        its slot freed immediately so a replacement is selectable this round.
+
+        Same effect as free_stalled_slot (slot ledger freed + delivery ledger
+        registered) — only the trigger differs from C.3. No-op when the gate is
+        off (trainer_event_dict is None) or proactive_inflight_evict is False (unaware
+        and aware-at-selection-only baselines stay on the C.3 90s path).
+        """
+        if not getattr(self, "proactive_inflight_evict", False):
+            return
+        if getattr(self, "trainer_event_dict", None) is None:
+            return
+        inflight = self._avail_inflight_ends(channel)
+        if not inflight:
+            return
+        now = self._avail_now()
+        buf = getattr(self, "_sim_buffer", None)
+        committed = getattr(self, "_sim_committed", set())
+        for end in list(inflight):
+            if buf is not None and buf.has(end):
+                continue  # update already arrived in buffer — not stalled
+            if end in committed or end in self.pending_withheld:
+                continue  # invariant 1: already committed / registered
+            trace = self.trainer_event_dict.get(end)
+            if not trace:
+                continue
+            if state_at(trace, now) != TrainerAvailState.UN_AVL:
+                continue  # still available — leave the slot
+            self.free_stalled_slot(
+                channel, end, reason="aware_boundary_eviction", sct=now
+            )
+            logger.info(
+                f"[AWARE_EVICT] end={str(end)[-4:]} vclock={now:.1f} "
+                f"state=UN_AVL — proactive boundary eviction"
+            )
+            if telemetry.is_enabled():
+                sst = channel.get_end_property(end, PROP_SIM_SEND_TS)
+                ev, f = build_abandon_timeout(
+                    round_num=getattr(self, "_round", -1), end_id=end,
+                    sim_send_ts=float(sst) if sst is not None else now,
+                    vclock_now=now, time_mode="sim",
+                    reason="aware_boundary_eviction",
+                )
+                telemetry.emit(ev, **f)
+
+    def _next_avail_vclock(self) -> Optional[float]:
+        """Stage F: earliest vclock at which any trainer next becomes selectable.
+
+        Returns the minimum of:
+        - next AVL_* transition for each currently-UN_AVL trainer's trace
+        - earliest pending withheld delivery_ts (withheld end re-enters pool then)
+
+        Used by starvation clock-advance: when no trainers are selectable, the
+        sim advances the vclock here rather than wall-sleeping, so the outer
+        retry immediately sees the newly-available cohort. Returns None when the
+        gate is off or no future availability exists in any trace.
+        """
+        if not getattr(self, "trainer_event_dict", None):
+            return None
+        now = self._avail_now()
+        candidates: list = []
+        for trace in self.trainer_event_dict.values():
+            nxt = next_avail_after(trace, now)
+            if nxt != math.inf:
+                candidates.append(nxt)
+        pw = getattr(self, "pending_withheld", None)
+        if pw:
+            candidates.extend(pw.values())
+        return min(candidates) if candidates else None
diff --git a/lib/python/flame/availability/trace.py b/lib/python/flame/availability/trace.py
new file mode 100644
index 000000000..32ee0d34a
--- /dev/null
+++ b/lib/python/flame/availability/trace.py
@@ -0,0 +1,196 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Shared availability trace resolver — single source of truth for agg and trainer.
+
+state_at / next_avail_after replace the three inlined bisect_right copies in
+get_curr_unavail_trainers (main_oort_sync_agg.py:311),
+_trace_read_avail_check (asyncfl/top_aggregator.py), and
+check_and_update_state_avl (trainer/pytorch/main.py:336).
+"""
+
+import logging
+import math
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from sortedcontainers import SortedDict
+
+from flame.config import TrainerAvailState
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_TRACE_DIR = (
+    Path(__file__).resolve().parents[2] / "examples/_metadata/availability_traces"
+)
+_METADATA_DIR = Path(__file__).resolve().parents[2] / "examples/_metadata"
+
+_MOBIPERF_SUBS: dict = {
+    "mobiperf_2st": "states_2st",
+    "mobiperf_3st_50": "states_3st_50",
+    "mobiperf_3st_75": "states_3st_75",
+}
+
+_AVL_STATE_VALUES = frozenset(
+    {TrainerAvailState.AVL_TRAIN.value, TrainerAvailState.AVL_EVAL.value}
+)
+
+
+# ---------------------------------------------------------------------------
+# Internal YAML cache — loaded once per (trace_dir) call site, never reloaded.
+# ---------------------------------------------------------------------------
+
+@lru_cache(maxsize=16)
+def _raw_mobiperf(trace_dir: str) -> dict:
+    # encoding="utf-8" explicit: open() otherwise falls back to the node's
+    # locale-preferred encoding, which mis-decodes any non-ASCII byte on a
+    # non-UTF-8 locale (e.g. C/POSIX) and yaml.safe_load then rejects the
+    # resulting control chars — bit us once already on the sibling parity
+    # YAML (see debug_run.sh).
+    with open(Path(trace_dir) / "mobiperf_traces.yaml", encoding="utf-8") as f:
+        return yaml.safe_load(f)["traces"]
+
+
+@lru_cache(maxsize=16)
+def _raw_synthetic(trace_dir: str) -> dict:
+    with open(Path(trace_dir) / "synthetic_traces.yaml", encoding="utf-8") as f:
+        return yaml.safe_load(f)["traces"]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def _canonical_trace_name(trace_name: str) -> str:
+    """Normalize a configured trace name to a canonical store key.
+
+    Legacy configs (trackTrainerAvail.trace) name traces with an ``avl_events_``
+    prefix, e.g. ``avl_events_syn_20`` / ``avl_events_mobiperf_2st``; newer ones
+    use the bare canonical name (``syn_20``). Strip the prefix so both resolve to
+    the same SortedDict — without this the legacy oort/refl JSON configs load 0
+    traces and the gate silently turns OFF.
+    """
+    if trace_name and trace_name.startswith("avl_events_"):
+        return trace_name[len("avl_events_"):]
+    return trace_name
+
+
+def load_trace(
+    trace_name: str,
+    trainer_key: str,
+    *,
+    base_dir: Optional[str] = None,
+) -> SortedDict:
+    """Return per-trainer availability as SortedDict[ts_s → state_str].
+
+    trace_name: canonical name — syn_0 / syn_20 / syn_50 / mobiperf_2st /
+        mobiperf_3st_50 / mobiperf_3st_75.
+    trainer_key: registry key ('trainer_001'). For mobiperf the numeric suffix
+        is used to derive the device key ('device_001').
+    base_dir: override for the trace store root; default = examples/_metadata/
+        availability_traces/.
+
+    syn_0 / all-available traces return an empty SortedDict (always AVL_TRAIN).
+    """
+    trace_dir = str(Path(base_dir) if base_dir else _DEFAULT_TRACE_DIR)
+    trace_name = _canonical_trace_name(trace_name)
+
+    if trace_name in _MOBIPERF_SUBS:
+        sub = _MOBIPERF_SUBS[trace_name]
+        raw = _raw_mobiperf(trace_dir)
+        num = trainer_key.split("_")[-1]
+        device_key = f"device_{num}"
+        events = raw[device_key][sub]
+    elif trace_name.startswith("syn_"):
+        raw = _raw_synthetic(trace_dir)
+        if trace_name not in raw:
+            raise KeyError(f"trace {trace_name!r} not found in synthetic_traces.yaml")
+        entry = raw[trace_name]
+        per_trainer = entry.get("per_trainer", {}).get("n300", {})
+        pattern = entry.get("pattern", [])
+        events = per_trainer.get(trainer_key) or pattern
+    else:
+        raise KeyError(f"unsupported trace name: {trace_name!r}")
+
+    result = SortedDict()
+    for ts, state in events:
+        result[float(ts)] = state
+    return result
+
+
+def state_at(trace: SortedDict, t: float) -> TrainerAvailState:
+    """Trainer availability at time t.
+
+    bisect_right(t)-1: the last event whose timestamp ≤ t.
+    Returns AVL_TRAIN (safe default) when no event has fired yet or trace is empty.
+    """
+    if not trace:
+        return TrainerAvailState.AVL_TRAIN
+    idx = trace.bisect_right(t) - 1
+    if idx < 0:
+        return TrainerAvailState.AVL_TRAIN
+    state_str = trace.peekitem(idx)[1]
+    try:
+        return TrainerAvailState(state_str)
+    except ValueError:
+        return TrainerAvailState.AVL_TRAIN
+
+
+def next_avail_after(trace: SortedDict, t: float) -> float:
+    """Smallest ts > t whose state ∈ {AVL_TRAIN, AVL_EVAL}.
+
+    Returns math.inf if the trace never recovers (caller must guard — Challenge 10).
+    """
+    idx = trace.bisect_right(t)
+    for i in range(idx, len(trace)):
+        ts, state = trace.peekitem(i)
+        if state in _AVL_STATE_VALUES:
+            return float(ts)
+    return math.inf
+
+
+def read_trainer_unavailability(
+    trace: Optional[str],
+    base_dir: Optional[str] = None,
+) -> Optional[dict]:
+    """Build task_id → SortedDict[ts_s → state_str] from the canonical store.
+
+    Free function (Batch 3 T3.2 Phase 2): extracted from
+    ClientAvailability.read_trainer_unavailability so scripts/parity/
+    ground_truth.py can call it directly without instantiating the mixin
+    class. That method now delegates here — same behavior, one implementation.
+
+    Reads examples/_metadata/trainer_registry.yaml once; individual trace
+    SortedDicts are built via load_trace() which caches the raw YAML.
+    Returns None on fatal errors (caller treats None as gate-off).
+    """
+    if not trace:
+        return None
+
+    registry_path = _METADATA_DIR / "trainer_registry.yaml"
+    try:
+        with open(registry_path, encoding="utf-8") as f:
+            registry = yaml.safe_load(f)["trainers"]
+    except FileNotFoundError:
+        logger.error(f"[AVAIL] trainer registry not found: {registry_path}")
+        return None
+
+    trainer_events_dict: dict = {}
+    errors = 0
+    for tk, meta in registry.items():
+        task_id = meta["task_id"]
+        try:
+            trainer_events_dict[task_id] = load_trace(trace, tk, base_dir=base_dir)
+        except (KeyError, FileNotFoundError) as exc:
+            logger.warning(f"[AVAIL] skipping {tk}: {exc}")
+            errors += 1
+
+    if errors:
+        logger.warning(
+            f"[AVAIL] {errors}/{len(registry)} trainers had missing trace data"
+        )
+    logger.info(
+        f"[AVAIL] loaded {len(trainer_events_dict)} trainer traces (trace={trace!r})"
+    )
+    return trainer_events_dict or None
diff --git a/lib/python/flame/config.py b/lib/python/flame/config.py
index 55dfef4a2..864bcc8da 100644
--- a/lib/python/flame/config.py
+++ b/lib/python/flame/config.py
@@ -153,7 +153,7 @@ class Hyperparameters(FlameSchema, extra=Extra.allow):
     eval_goal_factor: t.Optional[float] = Field(alias="evalGoalFactor", default=None)
     # Target-accuracy stopping: stop once test accuracy stays >= target for
     # `stable_evals_above_target` consecutive evals (resets on any dip). The
-    # existing `rounds` / `max_runtime_s` caps remain as the safety net so a
+    # existing `rounds` / `max_experiment_runtime_s` caps remain as the safety net so a
     # non-converging run still terminates. None disables the rule.
     target_accuracy: t.Optional[float] = Field(alias="targetAccuracy", default=None)
     stable_evals_above_target: t.Optional[int] = Field(
@@ -268,6 +268,30 @@ class Hyperparameters(FlameSchema, extra=Extra.allow):
     wait_until_next_avl: t.Optional[bool] = Field(
         alias="waitUntilNextAvail", default=False
     )
+    # Sim unavailability feature gate (§1 / §8.4). Default False ⇒ byte-identical
+    # to all existing runs. Set True to activate the oracular trace-read path.
+    sim_unavailability: t.Optional[bool] = Field(
+        alias="simUnavailability", default=False
+    )
+    # Per-baseline: aware baselines free stalled slots proactively at the next
+    # selection boundary (Stage D); unaware wait for the 90s vclock abandon.
+    # Kept for backward compat — new code reads proactive_inflight_evict first.
+    availability_aware: t.Optional[bool] = Field(
+        alias="availabilityAware", default=False
+    )
+    # Two-axis flag split (T1): avail_select_filter gates selection filtering;
+    # proactive_inflight_evict gates felix-only boundary eviction.
+    avail_select_filter: t.Optional[bool] = Field(
+        alias="availSelectFilter", default=True
+    )
+    proactive_inflight_evict: t.Optional[bool] = Field(
+        alias="proactiveInflightEvict", default=None
+    )
+    # Override directory for availability trace YAMLs. Defaults to
+    # examples/_metadata/availability_traces/ when None.
+    availability_trace_dir: t.Optional[str] = Field(
+        alias="availabilityTraceDir", default=None
+    )
     inc_model_version_per_data_id: t.Optional[bool] = Field(
         alias="incModelVersionPerDataId", default=False
     )
diff --git a/lib/python/flame/launch/experiment_config.py b/lib/python/flame/launch/experiment_config.py
index e1419afc3..ea74f07a7 100644
--- a/lib/python/flame/launch/experiment_config.py
+++ b/lib/python/flame/launch/experiment_config.py
@@ -37,6 +37,14 @@ class TrainerConfig:
 
     num_trainers: int = 300
     start_id: int = 1
+    # Which <name>_alpha<a>_n<N>.yaml split file to read, i.e. the N the
+    # dataset was partitioned for. Defaults to num_trainers. Set it larger
+    # than num_trainers to spawn a subset cohort (the first num_trainers
+    # trainers) against an existing wider partition -- e.g. num_trainers=10
+    # + split_num_trainers=300 runs a 10-trainer smoke off the n300 split
+    # without needing a dedicated n10 split file. See spawn_all's docstring:
+    # this N is a property of the partition, not of how many are spawned.
+    split_num_trainers: Optional[int] = None
     dataset: DatasetConfig = field(default_factory=DatasetConfig)
     availability: AvailabilityConfig = field(default_factory=AvailabilityConfig)
     battery_threshold: int = 50  # For 3-state modes
@@ -216,6 +224,7 @@ def from_yaml(cls, yaml_path: Path) -> "ExperimentBatch":
                 trainer=TrainerConfig(
                     num_trainers=trainer_data.get("num_trainers", 300),
                     start_id=trainer_data.get("start_id", 1),
+                    split_num_trainers=trainer_data.get("split_num_trainers"),
                     dataset=(
                         DatasetConfig(**dataset_data)
                         if dataset_data
diff --git a/lib/python/flame/launch/runner.py b/lib/python/flame/launch/runner.py
index a0e61064c..86eba2de3 100644
--- a/lib/python/flame/launch/runner.py
+++ b/lib/python/flame/launch/runner.py
@@ -161,6 +161,9 @@ def run_experiment(self, exp: ExperimentConfig) -> None:
             os.environ["FLAME_TELEMETRY_DIR"] = str(self.telemetry_dir)
             # UTF-8 child stdio so status glyphs don't crash on latin-1 locales.
             os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+            # Fault handler: on SIGSEGV/SIGFPE/etc. Python prints a C-level traceback
+            # to stderr (merged into _aggregator.log) before the process dies.
+            os.environ.setdefault("PYTHONFAULTHANDLER", "1")
 
             # CPU partition: reserve a few cores for the single, message-processing
             # -bound aggregator so the 300 pinned trainers don't time-slice it
@@ -284,24 +287,30 @@ def run_experiment(self, exp: ExperimentConfig) -> None:
                 trainer_main_path=paths["trainer_main"],
                 skip_index_splits=exp.trainer.dataset.path_style,
                 dataset_name=exp.trainer.dataset.name,
-                num_trainers=exp.trainer.num_trainers,
+                # Split-file selector is independent of the spawn cohort size:
+                # split_num_trainers (the N the partition was built for) falls
+                # back to num_trainers when unset. trainer_ids above still
+                # spawns exactly num_trainers trainers.
+                num_trainers=exp.trainer.split_num_trainers or exp.trainer.num_trainers,
                 per_trainer_overrides=per_trainer_overrides,
                 **config_overrides,
             )
 
             print(f"\nexperiment running. logs: {agg_log}, {trainers_log}")
             # Wait for the aggregator to finish all rounds first, then give
-            # trainers a short grace window to process the EOT broadcast and
-            # exit cleanly. Without this, wait_all()'s per-trainer timeout fires
-            # immediately after spawn and kills trainers every 30s regardless of
+            # trainers a short grace window (shared across the whole cohort,
+            # not serialized per-process) to process the EOT broadcast and
+            # exit cleanly. Without this, wait_all()'s timeout fires
+            # immediately after spawn and kills trainers regardless of
             # whether training is still in progress.
-            # Watchdog: the aggregator self-stops at max_runtime_s (real) / sim_wall_ceiling_s
-            # (sim). If it instead DEADLOCKS (MQTT/barrier) it would block this wait forever and
-            # hang the batch. Bound the wait at the run's budget + a generous grace and hard-kill
-            # on timeout so the batch proceeds to _cleanup/_sweep_stragglers instead of hanging.
+            # Watchdog: the aggregator self-stops at max_experiment_runtime_s (real) /
+            # sim_wall_ceiling_s (sim). If it instead DEADLOCKS (MQTT/barrier) it would
+            # block this wait forever and hang the batch. Bound the wait at the run's
+            # budget + a generous grace and hard-kill on timeout so the batch proceeds
+            # to _cleanup/_sweep_stragglers instead of hanging.
             hp = agg_cfg.get("hyperparameters", {}) or {}
             try:
-                budget_s = max(float(hp.get("max_runtime_s") or 0.0),
+                budget_s = max(float(hp.get("max_experiment_runtime_s") or 0.0),
                                float(hp.get("sim_wall_ceiling_s") or 0.0))
             except (TypeError, ValueError):
                 budget_s = 0.0
@@ -312,7 +321,9 @@ def run_experiment(self, exp: ExperimentConfig) -> None:
                 print(f"  ⚠ aggregator still running after watchdog {wd_msg} — "
                       f"assuming deadlock; killing it (run budget was {budget_s:.0f}s)")
                 self.aggregator_spawner.terminate()
-            print("  aggregator done, waiting for trainers to exit...")
+            agg_rc = getattr(self.aggregator_spawner.process, "returncode", None)
+            rc_msg = f"exit={agg_rc}" if agg_rc == 0 else f"exit={agg_rc} ⚠"
+            print(f"  aggregator done ({rc_msg}), waiting for trainers to exit...")
             self.trainer_spawner.wait_all(timeout_per_trainer=30.0)
             print("\nexperiment completed.")
 
diff --git a/lib/python/flame/launch/spawner.py b/lib/python/flame/launch/spawner.py
index 1216d1425..e82568111 100644
--- a/lib/python/flame/launch/spawner.py
+++ b/lib/python/flame/launch/spawner.py
@@ -59,9 +59,24 @@ def get_dataset_split(
         trainer_key = f"trainer_{trainer_id:03d}"
         return self.dataset_splits[split_key]["trainer_data_splits"][trainer_key]
 
-    def get_synthetic_trace(self, trace_name: str) -> List:
-        """Get synthetic availability trace."""
-        return self.synthetic_traces["traces"][trace_name]["pattern"]
+    def get_synthetic_trace(
+        self, trace_name: str, trainer_id: Optional[int] = None
+    ) -> List:
+        """Get synthetic availability trace.
+
+        trainer_id=None returns the shared `pattern` entry. Pass trainer_id to
+        resolve that trainer's own `per_trainer` entry via the same resolver
+        (flame.availability.trace.load_trace) the aggregator already uses.
+        """
+        if trainer_id is None:
+            return self.synthetic_traces["traces"][trace_name]["pattern"]
+        from flame.availability.trace import load_trace
+
+        trainer_key = f"trainer_{trainer_id:03d}"
+        trace_dict = load_trace(
+            trace_name, trainer_key, base_dir=str(self.metadata_dir / "availability_traces")
+        )
+        return [[ts, state] for ts, state in trace_dict.items()]
 
     def get_mobiperf_trace(self, trainer_id: int, variant: str = "2st") -> List:
         """Get mobiperf trace for a trainer."""
@@ -150,13 +165,13 @@ def generate_trainer_config(
         elif availability_mode.startswith("syn_"):
             trace_name = availability_mode
             config["hyperparameters"][f"avl_events_{trace_name}"] = (
-                self.metadata.get_synthetic_trace(trace_name)
+                self.metadata.get_synthetic_trace(trace_name, trainer_id)
             )
 
         # Add all synthetic traces (for flexibility)
         for trace_name in ["syn_0", "syn_20", "syn_50"]:
             config["hyperparameters"][f"avl_events_{trace_name}"] = (
-                self.metadata.get_synthetic_trace(trace_name)
+                self.metadata.get_synthetic_trace(trace_name, trainer_id)
             )
 
         # Add all mobiperf traces
@@ -416,40 +431,49 @@ def spawn_all(
     def wait_all(self, timeout_per_trainer: float = 30.0):
         """Wait for all trainer processes to complete.
 
-        All trainers share one ``timeout_per_trainer``-second window after the
-        aggregator exits to process the EOT broadcast and self-terminate.
-        Trainers that are blocked in ``await_join`` (waiting for the next task
+        All trainers share a single ``timeout_per_trainer`` second window
+        after the aggregator exits to process the EOT broadcast and
+        self-terminate, polled concurrently — not one process at a time, or
+        N stragglers would serialize the shutdown into N * timeout_per_trainer
+        (e.g. 5 stuck trainers at 30s each adds 2.5 minutes of pure idle
+        wait). Trainers blocked in ``await_join`` (waiting for the next task
         from an aggregator that has already left) will never self-exit, so we
-        force-terminate whichever ones are still alive once the shared window
-        elapses. This polls all processes concurrently rather than waiting on
-        them one at a time -- a sequential per-trainer wait would cost up to
-        ``timeout_per_trainer * len(self.processes)`` when every trainer
-        misses the EOT broadcast, turning a single 30s window into minutes of
-        dead time before the next sequential experiment can start.
+        force-terminate whatever is left after the window, then kill anything
+        still alive after a short grace period. Without this the runner hangs
+        indefinitely and the next sequential experiment never starts.
         """
-        procs = [proc_info["process"] for proc_info in self.processes]
-
-        deadline = time.monotonic() + timeout_per_trainer
-        while time.monotonic() < deadline:
-            if all(proc.poll() is not None for proc in procs):
-                break
-            time.sleep(0.5)
-
-        for proc in procs:
-            if proc.poll() is not None:
-                continue
-            print(
-                f"  (trainer PID {proc.pid} did not exit within "
-                f"{timeout_per_trainer}s; terminating)"
-            )
+        deadline = time.time() + timeout_per_trainer
+        pending = [p["process"] for p in self.processes]
+
+        while pending and time.time() < deadline:
+            pending = [p for p in pending if p.poll() is None]
+            if pending:
+                time.sleep(0.5)
+
+        if not pending:
+            return
+
+        print(
+            f"  ({len(pending)} trainer(s) did not exit within "
+            f"{timeout_per_trainer:.0f}s; terminating)"
+        )
+        for proc in pending:
             try:
                 proc.terminate()
-                proc.wait(timeout=5)
             except Exception:
-                try:
-                    proc.kill()
-                except Exception:
-                    pass
+                pass
+
+        kill_deadline = time.time() + 5
+        while pending and time.time() < kill_deadline:
+            pending = [p for p in pending if p.poll() is None]
+            if pending:
+                time.sleep(0.5)
+
+        for proc in pending:
+            try:
+                proc.kill()
+            except Exception:
+                pass
 
     def terminate_all(self):
         """Terminate all trainer processes."""
diff --git a/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py b/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py
index 6011cc77b..41e2fbda6 100644
--- a/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py
+++ b/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py
@@ -112,6 +112,16 @@ def internal_init(self) -> None:
         self._sim_buffer = SimReorderBuffer()
         self._sim_committed: set = set()
         self._sim_pending_commit: set = set()
+        # C.2 send-time withhold: an in-flight update whose trainer is UN_AVL at
+        # its completion (sct) is HELD here (end -> (sct, (msg, metadata))) and
+        # re-injected into the buffer at its delivery_ts (commits stale). The
+        # delivery_ts itself lives in the ClientAvailability pending_withheld ledger.
+        self._sim_withheld_payload: dict = {}
+        # end -> (orig_sct, delivery_ts) for an update currently re-injected into the
+        # buffer awaiting its late (stale) commit. Lets the commit body recognize a
+        # withheld delivery (vs a fresh/straggler commit) so it tags the "withheld"
+        # past-dating bucket and emits the withheld_delivery rung with the true delay.
+        self._sim_withheld_delivering: dict = {}
         self._sim_enqueue_round = {}  # end -> round it entered the reorder buffer
         # Virtual-completion gate: the aggregator's record of each in-flight trainer's
         # EXPECTED completion = dispatch vclock + its MODELED budget. Lets _sim_recv_min hold
@@ -296,6 +306,11 @@ def _sim_end_has_ready_msg(channel, end) -> bool:
         except Exception:
             return False
 
+    # C.2 / C.3 commit-loop wiring (_sim_pop_committable, _sim_reinject_ready_withheld,
+    # _sim_abandon_stalled) is shared, library-level in ClientAvailability so the oort
+    # stack rides the identical logic. The asyncfl gate tracker (_sim_inflight_expected)
+    # is reached via the mixin's guarded _avail_drop_inflight hook.
+
     def _sim_recv_min(self, channel, recv_ends):
         """Barrier: drain the in-flight set, then commit the smallest
         sim_completion_ts. The virtual clock advances TO each committed completion
@@ -307,6 +322,8 @@ def _sim_recv_min(self, channel, recv_ends):
         verifies the clock is now sct-driven."""
         if not hasattr(self, "_sim_inflight_expected"):  # bare-init guard (tests)
             self._sim_inflight_expected = {}
+            self._sim_withheld_payload = {}
+            self._sim_withheld_delivering = {}
             self._sim_trainer_budget = {}
             self._sim_budget_running_mean = 12.0
             self._sim_budget_n = 0
@@ -431,8 +448,13 @@ def _ingest(msg, metadata):
         self._note_sim_fill(barrier_wait, drained_all)
 
         # Pop the minimum regardless of recv_ends membership so buffered updates
-        # are not lost when an end is cleaned up before its commit.
-        popped = self._sim_buffer.pop_min()
+        # are not lost when an end is cleaned up before its commit. First re-inject
+        # any withheld update whose delivery_ts has arrived (C.2), then pop the
+        # smallest update that is actually committable — an in-flight trainer that is
+        # UN_AVL at its completion (sct) is send-gated: held now, delivered stale at
+        # delivery_ts. Gate off ⇒ both are no-ops / a single pop (byte-identical).
+        self._sim_reinject_ready_withheld()
+        popped = self._sim_pop_committable(channel)
         if popped is None:
             return None, ("", datetime.now())
         _end, sct, (m, md) = popped
@@ -460,6 +482,17 @@ def _ingest(msg, metadata):
             self._sim_commit_count = {}
         self._sim_commit_count[_end] = self._sim_commit_count.get(_end, 0) + 1
         self._sim_committed.add(_end)
+        # C.2 withheld delivery: this commit is the late (stale) delivery of an
+        # update that was send-gated while its trainer was UN_AVL. Tag it so the
+        # past-dating attribution uses the "withheld" bucket (intended staleness,
+        # not a pacing bug) and emit the withheld_delivery rung with the true
+        # down-window delay (delivery_ts − original sct) and resulting staleness.
+        # Async (fedbuff weighting) accept-stale ⇒ accepted=True; sync feddance
+        # reject-over-tolerance is wired in Stage E.
+        _withheld_meta = self._sim_take_withheld_delivering(_end)
+        _is_withheld = _withheld_meta is not None
+        if _is_withheld:
+            self._emit_withheld_delivery(_end, m, _withheld_meta[0], _withheld_meta[1])
         # start this end's post-commit re-dispatch cooldown. Held out of
         # selection (in _distribute_weights) until vclock >= sct + gap, so it
         # returns with a fresher model_version -- the gap spaces completions
@@ -514,7 +547,9 @@ def _ingest(msg, metadata):
             # rounds ago this update was trained (current round - its MODEL_VERSION).
             _mv = m.get(MessageType.MODEL_VERSION) if isinstance(m, dict) else None
             _round_lag = (self._round - int(_mv)) if _mv is not None else None
-            if self._round <= 1:
+            if _is_withheld:
+                _src = "withheld"  # intended late stale delivery, not a pacing bug
+            elif self._round <= 1:
                 _src = "round1"
             elif _was_recommit:
                 _src = "redispatch"
@@ -614,7 +649,40 @@ def _aggregate_weights(self, tag: str) -> None:
                 recv_ends = []  # buffer still has entries to drain — don't block
             else:
                 logger.debug(f"[AGG_RECV] no live recv ends (round={self._round}); skipping")
-                time.sleep(0.5)
+                # F.2: in sim, advance vclock to next availability event instead of
+                # wall-sleeping — covers felix and fedbuff asyncfl starvation paths.
+                if self.simulated and self.trainer_event_dict is not None:
+                    _nxt = self._next_avail_vclock()
+                    _budget = float(
+                        getattr(self.config.hyperparameters, "max_experiment_runtime_s", float("inf"))
+                    )
+                    if _nxt is not None and _nxt > self._vclock.now and self._vclock.now < _budget:
+                        self._vclock.advance(_nxt)
+                        logger.info(
+                            f"[SIM_STARVATION] round={self._round} no recv ends; "
+                            f"vclock→{_nxt:.1f}"
+                        )
+                    else:
+                        # Trace horizon or budget reached — stop instead of spinning.
+                        self._work_done = True
+                        logger.info(
+                            f"[SIM_STARVATION] trace horizon or budget reached at "
+                            f"vclock={self._vclock.now:.1f}s (nxt={_nxt}, "
+                            f"budget={_budget:.0f}s, round={self._round}); stopping run."
+                        )
+                else:
+                    _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None)
+                    if _max_rt:
+                        _wall_elapsed = time.time() - self.agg_start_time_ts
+                        if _wall_elapsed >= float(_max_rt):
+                            self._work_done = True
+                            logger.info(
+                                f"max_experiment_runtime_s={_max_rt}s reached "
+                                f"(wall_elapsed={_wall_elapsed:.0f}s) at round {self._round}; "
+                                f"stopping run."
+                            )
+                            return
+                    time.sleep(0.5)
                 return
         if self.simulated:
             msg, metadata = self._sim_recv_min(channel, recv_ends)
@@ -626,6 +694,10 @@ def _aggregate_weights(self, tag: str) -> None:
         if not msg:
             logger.debug(f"[AGG_RECV] No data from {end}; skipping it, agg_model_version={self._round}")
             return
+        # T3.3 commit-checkpoint belief (real mode only — sim's own commit
+        # loop already recorded it inside _sim_withhold_if_unavail).
+        if not self.simulated:
+            self._record_commit_belief(end)
         _t_msg_start = datetime.now()  # start of per-message processing (vii)
 
         # NOTE: Only 2 types of messages are expected here: (i) model
@@ -1246,8 +1318,8 @@ def _aggregate_weights(self, tag: str) -> None:
         if self.simulated:
             self._sim_hold_busy_slots(channel)
 
-    def oracular_trainer_avail_check(self, end: str) -> bool:
-        logger.debug("In oracular_trainer_avail_check")
+    def _trace_read_avail_check(self, end: str) -> bool:
+        logger.debug("In _trace_read_avail_check")
 
         picked_trainer_is_available = True
 
@@ -1360,7 +1432,7 @@ def check_trainer_availability(self, end: str) -> bool:
         if self.track_trainer_avail["enabled"] == "False":
             return True
         elif self.track_trainer_avail["type"] == "ORACULAR":
-            picked_trainer_is_available = self.oracular_trainer_avail_check(end)
+            picked_trainer_is_available = self._trace_read_avail_check(end)
         elif self.track_trainer_avail["type"] == "HEARTBEAT":
             picked_trainer_is_available = self.hearbeat_trainer_avail_check(end)
 
@@ -1443,8 +1515,34 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
             # Settle channel state before selection (real only); 0 removes this brake.
             time.sleep(self._real_distribute_settle_s)
 
+        # C.3: re-clock the 90s abandon to the vclock and free stalled slots so a
+        # replacement is selectable this round (no-op when the gate is off).
+        # Sim-only: real mode already has a native wall-clock abandon in the
+        # selector itself (SEND_TIMEOUT_WAIT_S), so this would be redundant there.
+        if self.simulated:
+            self._sim_abandon_stalled(channel)
+        # D.1: for proactive_inflight_evict baselines (felix only), free any
+        # in-flight slot the trace now shows as UN_AVL -- no 90s wait. Both modes:
+        # trace-read eviction has no real-mode equivalent (unlike the abandon
+        # above), so gating it sim-only left real-mode felix runs with no way to
+        # drop a stalled UN_AVL trainer from recv_ends, hanging forever once
+        # enough trainers went quiet (see Batch 4 finding 1, UNAVAILABILITY_DESIGN.md).
+        self._sim_evict_unavail_inflight(channel)
+
         if self.trainer_event_dict is not None:
-            curr_unavail_trainer_list = self.get_curr_unavail_trainers()
+            # D.2: task-aware — also excludes AVL_EVAL from "train" dispatch and
+            # AVL_TRAIN from "eval" dispatch (inert where a baseline never
+            # dispatches eval, Challenge 8).
+            curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers(
+                task_to_perform
+            )
+            # invariant 2: a trainer with a withheld update stays out of the
+            # eligible pool until its delivery_ts (§4.5 residence, sct→delivery_ts).
+            _held_withheld = self.withheld_held_ends()
+            if _held_withheld:
+                curr_unavail_trainer_list = list(
+                    set(curr_unavail_trainer_list) | _held_withheld
+                )
         else:
             curr_unavail_trainer_list = []
 
@@ -1479,16 +1577,22 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         channel.set_curr_unavailable_trainers(
             trainer_unavail_list=curr_unavail_trainer_list
         )
+        # Stamp PROP_AVL_STATE on every known end (incl. in-flight ones D.1/C.3
+        # just evicted) so emit_selection's avail_composition/per_trainer reflect
+        # the oracular read instead of staying all-UNKNOWN.
+        self._avail_stamp_end_states(channel)
 
-        # Expose current vclock to selector so it can attach it to selection events.
-        if self.simulated:
-            channel.properties["vclock_now"] = self._vclock.now
+        # Expose current availability-timeline time to selector so it can attach
+        # it to selection events. _avail_now() covers both modes — real used to
+        # be skipped here (see syncfl/top_aggregator.py for the parity fallout).
+        channel.properties["vclock_now"] = self._avail_now()
 
         # Per-baseline online oracle: refresh candidate stat-utility to true values
         # before selection. No-op unless oracle_utility_injection is enabled.
         self._inject_oracle_utilities(channel, task_to_perform)
 
-        ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform)
+        ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform,
+                            agg_version_state=(self._round, None, None))
         if not ends:
             logger.debug(f"No trainers found for tag {tag}")
             return
@@ -1543,6 +1647,11 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         if not _staggered:
             if self.simulated:
                 base_msg[MessageType.SIM_SEND_TS] = _round_now
+            else:
+                # T3.0: broadcast the trace-read origin so a trainer's own
+                # wall-clock availability lookups anchor to the SAME point the
+                # aggregator uses.
+                base_msg[MessageType.AGG_START_TS] = self.agg_start_time_ts
             _shared_payload = channel.dumps(base_msg)
 
         _send_t0 = time.time()  # [DISTRIBUTE_TIMING]
diff --git a/lib/python/flame/mode/horizontal/oort/top_aggregator.py b/lib/python/flame/mode/horizontal/oort/top_aggregator.py
index 14836c014..ea15e4029 100644
--- a/lib/python/flame/mode/horizontal/oort/top_aggregator.py
+++ b/lib/python/flame/mode/horizontal/oort/top_aggregator.py
@@ -126,16 +126,40 @@ def _oort_sim_recv(self, channel, end_ids):
         # under-fire (in-flight drains to ~0.15 instead of real's ~4.6).
         try:
             while True:
+                # C.2: re-inject any withheld update whose delivery_ts has arrived
+                # (no-op when the gate is off ⇒ pop loop unchanged, byte-identical).
+                self._sim_reinject_ready_withheld()
                 popped = buf.pop_min()
                 if popped is None:
                     break
                 end, sct, (msg, md) = popped
-                if carryover:
+                # A re-injected late stale delivery has already completed and is
+                # exempt from BOTH the carry-over gate (it is not still-computing)
+                # and the send-gate (its trainer is AVL_* at delivery_ts).
+                _is_withheld_delivery = end in getattr(
+                    self, "_sim_withheld_delivering", {}
+                )
+                if carryover and not _is_withheld_delivery:
                     _tr = msg.get(MessageType.MODEL_VERSION, 0)
                     if (self._round - _tr) > 0 and sct > vclock_round_start:
                         held_over.append((end, sct, (msg, md)))
                         continue
+                # C.2 send-gate: a COMPLETED update whose trainer is UN_AVL at sct
+                # is held and delivered stale at delivery_ts. Applied AFTER carry-over
+                # so a still-computing future-sct straggler (which has not reached its
+                # send-gate) stays in-flight (Challenge 7 composition).
+                if not _is_withheld_delivery and self._sim_withhold_if_unavail(
+                    channel, end, sct, (msg, md)
+                ):
+                    continue
+                # Late stale delivery: emit the withheld_delivery rung (best-effort).
+                # Batch 3 T3.5 (K11): advance before emitting, matching asyncfl's
+                # existing order — see _emit_withheld_delivery's docstring for why
+                # this specific advance is provably a no-op here either way.
+                _wd = self._sim_take_withheld_delivering(end)
                 self._advance_sim_clock(sct)
+                if _wd is not None:
+                    self._emit_withheld_delivery(end, msg, _wd[0], _wd[1])
                 _srd = msg.get(MessageType.SIM_CLIENT_TASK_TRAIN_DURATION_S)
                 _sst = channel.get_end_property(end, PROP_SIM_SEND_TS)
                 if _srd is not None:
@@ -226,6 +250,24 @@ def _aggregate_weights(self, tag: str) -> None:
 
         received_end_count = 0
 
+        # Real mode only: bound recv_fifo with a wall-clock timeout (default
+        # trainer_recv_wall_timeout_s=90s, >> the 18s max trainer speed in
+        # async_cifar10) so unavailable trainers can't stall the aggregator
+        # indefinitely; capped at the remaining max_experiment_runtime_s
+        # budget so the process never overshoots it. Sim mode leaves
+        # _recv_timeout=None — the vclock drives termination there instead.
+        _recv_timeout = None
+        if not self.simulated:
+            _stall = float(getattr(
+                self.config.hyperparameters, "trainer_recv_wall_timeout_s", 90.0
+            ))
+            _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None)
+            if _max_rt:
+                _remaining = max(1.0, float(_max_rt) - (time.time() - self.agg_start_time_ts))
+                _recv_timeout = min(_stall, _remaining)
+            else:
+                _recv_timeout = _stall
+
         # simulated: commit the aggr_num updates with the smallest
         # sim_completion_ts (the k that would physically finish first in real),
         # reordering away physical arrival jitter and advancing the virtual
@@ -237,7 +279,7 @@ def _aggregate_weights(self, tag: str) -> None:
             self._round_start_vclock = self._vclock.now
             _recv = self._oort_sim_recv(channel, end_ids)
         else:
-            _recv = channel.recv_fifo(end_ids, aggr_num)
+            _recv = channel.recv_fifo(end_ids, aggr_num, timeout=_recv_timeout)
 
         for msg, metadata in _recv:
             end, _ = metadata
@@ -246,6 +288,11 @@ def _aggregate_weights(self, tag: str) -> None:
                 logger.info(f"[MSG_SKIP] No data from ...{end[-8:]}; skipping it")
                 continue
 
+            # T3.3 commit-checkpoint belief (real mode only — sim's own commit
+            # loop already recorded it inside _sim_withhold_if_unavail).
+            if not self.simulated:
+                self._record_commit_belief(end)
+
             # Calculate staleness
             trainer_round = msg.get(MessageType.MODEL_VERSION, 0)
             staleness = self._round - trainer_round
@@ -348,7 +395,7 @@ def _aggregate_weights(self, tag: str) -> None:
             _recv2 = (
                 self._oort_sim_recv(channel, end_ids)
                 if self.simulated
-                else channel.recv_fifo(end_ids, 1)
+                else channel.recv_fifo(end_ids, 1, timeout=_recv_timeout)
             )
             for msg, metadata in _recv2:
                 end, _ = metadata
@@ -358,6 +405,11 @@ def _aggregate_weights(self, tag: str) -> None:
                     continue
                 progressed = True
 
+                # T3.3 commit-checkpoint belief (real mode only — sim's own
+                # commit loop already recorded it inside _sim_withhold_if_unavail).
+                if not self.simulated:
+                    self._record_commit_belief(end)
+
                 # Calculate staleness
                 trainer_round = msg.get(MessageType.MODEL_VERSION, 0)
                 staleness = self._round - trainer_round
@@ -608,31 +660,30 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         aggr_num = self.config.selector.kwargs.get("aggr_num", 10)
         overcommitment = getattr(channel._selector, 'overcommitment', 1.3)
         desired_selection = int(aggr_num * overcommitment)
-        
-        # Configuration for wait-retry mechanism
-        max_retries = self.config.selector.kwargs.get('max_selection_retries', 5)
-        retry_wait_seconds = self.config.selector.kwargs.get('selection_retry_wait', 2.0)
-        min_trainers_ratio = self.config.selector.kwargs.get('min_trainers_ratio', 0.5)  # At least 50% of aggr_num
-        
-        # CRITICAL: If min_trainers_ratio >= overcommitment, wait for FULL desired_selection
-        # This prevents sending weights to partial sets that may never respond
-        if min_trainers_ratio >= overcommitment:
-            min_required_trainers = desired_selection  # Wait for all 13 trainers
-            logger.info(
-                f"[DISTRIBUTE] Round {self._round}: Strict mode - will wait for FULL desired_selection={desired_selection} trainers"
-            )
-        else:
-            min_required_trainers = max(1, int(aggr_num * min_trainers_ratio))
-        
+
         logger.info(
-            f"[DISTRIBUTE] Round {self._round}: Desired selection={desired_selection} "
-            f"(aggr_num={aggr_num}, overcommit={overcommitment}), "
-            f"min_required={min_required_trainers}"
+            f"[DISTRIBUTE] Round {self._round}: desired_selection={desired_selection} "
+            f"(aggr_num={aggr_num}, overcommit={overcommitment})"
         )
 
         # before distributing weights, update it from global model
         self._update_weights()
 
+        # C.3: re-clock the 90s abandon to the vclock and free stalled slots so a
+        # replacement is selectable this round (no-op when the gate is off).
+        # Sim-only: real mode already has a native wall-clock abandon in the
+        # selector itself (SEND_TIMEOUT_WAIT_S), so this would be redundant there.
+        if self.simulated:
+            self._sim_abandon_stalled(channel)
+        # D.1: for availability_aware baselines, proactively free any in-flight
+        # slot the trace now shows as UN_AVL -- no 90s wait. Both modes: trace-read
+        # eviction has no real-mode equivalent (unlike the abandon above), so
+        # gating it sim-only left real-mode felix runs with no way to drop a
+        # stalled UN_AVL trainer from recv_ends (see Batch 4 finding 1,
+        # UNAVAILABILITY_DESIGN.md). No-op here (oort's proactive_inflight_evict
+        # is False), kept for symmetry with the other two stacks.
+        self._sim_evict_unavail_inflight(channel)
+
         # Per-baseline online oracle: overwrite candidate stat-utility with true
         # current values before the selector ranks. No-op unless enabled.
         self._inject_oracle_utilities(channel, task_to_perform)
@@ -640,7 +691,19 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         # before invoking channel.ends() to select, set the
         # trainer_unavail if it isn't None
         if self.trainer_event_dict is not None:
-            curr_unavail_trainer_list = self.get_curr_unavail_trainers()
+            # D.2: task-aware — also excludes AVL_EVAL from "train" dispatch and
+            # AVL_TRAIN from "eval" dispatch (inert where a baseline never
+            # dispatches eval, e.g. oort, Challenge 8).
+            curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers(
+                task_to_perform
+            )
+            # invariant 2: a trainer with a withheld update stays out of the
+            # eligible pool until its delivery_ts (§4.5 residence, sct→delivery_ts).
+            _held_withheld = self.withheld_held_ends()
+            if _held_withheld:
+                curr_unavail_trainer_list = list(
+                    set(curr_unavail_trainer_list) | _held_withheld
+                )
         else:
             curr_unavail_trainer_list = []
 
@@ -669,97 +732,104 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         channel.set_curr_unavailable_trainers(
             trainer_unavail_list=curr_unavail_trainer_list
         )
+        # Stamp PROP_AVL_STATE on every known end (incl. in-flight ones D.1/C.3
+        # just evicted) so emit_selection's avail_composition/per_trainer reflect
+        # the oracular read instead of staying all-UNKNOWN.
+        self._avail_stamp_end_states(channel)
+
+        # Expose current availability-timeline time to selector so it can attach
+        # it to selection events (C.6.1 — restores per-trainer avl_state identity
+        # at emit time). _avail_now() covers both modes — real used to be
+        # skipped here (see syncfl/top_aggregator.py for the parity fallout).
+        channel.properties["vclock_now"] = self._avail_now()
 
         logger.debug(
             f"Sending weights to trainers with task_to_perform = {task_to_perform}"
         )
-        
-        # CRITICAL FIX: Implement wait-retry mechanism for trainer selection
-        # If insufficient trainers are available, wait and retry instead of proceeding
-        selected_ends = None
-        retry_count = 0
-        
-        while retry_count <= max_retries:
-            # Get currently available trainer ends
-            all_ends = list(channel._ends.keys())
-            
-            # Get unavailable trainers
-            if self.trainer_event_dict is not None:
-                unavail_trainers = set(self.get_curr_unavail_trainers())
-            else:
-                unavail_trainers = set()
-            
-            # Get in-flight trainers (already selected, waiting for updates)
-            in_flight_trainers = getattr(channel._selector, 'selected_ends', set())
-            if not isinstance(in_flight_trainers, set):
-                in_flight_trainers = set(in_flight_trainers) if in_flight_trainers else set()
-            
-            # Calculate eligible trainers
-            eligible_trainers = [
-                end for end in all_ends
-                if end not in unavail_trainers and end not in in_flight_trainers
-            ]
-            
-            num_eligible = len(eligible_trainers)
-            
-            logger.info(
-                f"[DISTRIBUTE] Round {self._round}, Attempt {retry_count + 1}/{max_retries + 1}: "
-                f"total_ends={len(all_ends)}, unavailable={len(unavail_trainers)}, "
-                f"in_flight={len(in_flight_trainers)}, eligible={num_eligible}, "
-                f"required={min_required_trainers}"
+
+        # F.2: Pre-selection threshold check — return-early if pool is scarce.
+        # Threshold = desired_selection (full overcommitted batch); unbounded retry,
+        # no max_retries ceiling, no "proceed anyway" fallback for sync FL.
+        _in_flight = getattr(channel._selector, 'selected_ends', set())
+        if not isinstance(_in_flight, set):
+            _in_flight = set(_in_flight) if _in_flight else set()
+        _connected = set(channel._ends.keys())
+        num_eligible = len(_connected - set(curr_unavail_trainer_list) - _in_flight)
+
+        # Cohort-floor guardrail: if desired_selection > connected cohort size
+        # (e.g. n=12 with desired_selection=13), the starvation gate fires
+        # every round and exhausts the budget with zero training (observed
+        # Jun 29, accidental n=12 oort). Clamp + warn once instead of
+        # silently degenerating into an all-starvation run.
+        _starv_threshold = min(desired_selection, len(_connected))
+        if desired_selection > len(_connected) and not getattr(
+            self, "_oort_cohort_floor_warned", False
+        ):
+            logger.warning(
+                f"[COHORT_FLOOR] desired_selection={desired_selection} > connected "
+                f"cohort={len(_connected)}: the overcommitted batch can never be met. "
+                f"Clamping starvation threshold to {len(_connected)}. Increase "
+                f"num_trainers to >= desired_selection for a valid oort starvation run."
             )
-            
-            # Check if we have enough eligible trainers
-            if num_eligible >= min_required_trainers:
-                logger.info(
-                    f"[DISTRIBUTE] Round {self._round}: Sufficient trainers available "
-                    f"({num_eligible} >= {min_required_trainers}), proceeding with selection. "
-                    f"Will select min({desired_selection}, {num_eligible}) trainers."
-                )
-                break
-            else:
-                # Insufficient trainers - log warning
-                logger.warning(
-                    f"[DISTRIBUTE] Round {self._round}, Attempt {retry_count + 1}: "
-                    f"INSUFFICIENT trainers! eligible={num_eligible} < required={min_required_trainers}. "
-                    f"Breakdown: total={len(all_ends)}, unavail={len(unavail_trainers)}, "
-                    f"in_flight={len(in_flight_trainers)}"
+            self._oort_cohort_floor_warned = True
+
+        if num_eligible < _starv_threshold:
+            if self.simulated and self.trainer_event_dict is not None:
+                _nxt = self._next_avail_vclock()
+                _budget = float(
+                    getattr(self.config.hyperparameters, "max_experiment_runtime_s", float("inf"))
                 )
-                
-                if retry_count < max_retries:
-                    logger.warning(
-                        f"[DISTRIBUTE] Waiting {retry_wait_seconds}s before retry {retry_count + 2}/{max_retries + 1}..."
+                if _nxt is not None and _nxt > self._vclock.now and self._vclock.now < _budget:
+                    self._vclock.advance(_nxt)
+                    self._sim_abandon_stalled(channel)
+                    curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers(
+                        task_to_perform
                     )
-                    time.sleep(retry_wait_seconds)
-                    retry_count += 1
-                    # Update unavailability list before retry
-                    if self.trainer_event_dict is not None:
-                        curr_unavail_trainer_list = self.get_curr_unavail_trainers()
-                        channel.set_curr_unavailable_trainers(
-                            trainer_unavail_list=curr_unavail_trainer_list
+                    _held = self.withheld_held_ends()
+                    if _held:
+                        curr_unavail_trainer_list = list(
+                            set(curr_unavail_trainer_list) | _held
                         )
+                    channel.set_curr_unavailable_trainers(
+                        trainer_unavail_list=curr_unavail_trainer_list
+                    )
+                    self._avail_stamp_end_states(channel)
+                    channel.properties["vclock_now"] = self._vclock.now
+                    logger.info(
+                        f"[SIM_STARVATION] round={self._round} eligible={num_eligible} "
+                        f"< {_starv_threshold}; vclock→{_nxt}"
+                    )
                 else:
-                    # Max retries exceeded - proceed with warning
-                    logger.error(
-                        f"[DISTRIBUTE] Round {self._round}: Max retries ({max_retries}) exceeded. "
-                        f"Proceeding with ONLY {num_eligible} trainers (required: {min_required_trainers}, "
-                        f"desired: {desired_selection}). THIS MAY IMPACT TRAINING QUALITY!"
+                    # Trace horizon or budget reached — stop instead of spinning.
+                    self._work_done = True
+                    logger.info(
+                        f"[SIM_STARVATION] trace horizon or budget reached at "
+                        f"vclock={self._vclock.now:.1f}s (nxt={_nxt}, "
+                        f"budget={_budget:.0f}s, round={self._round}); stopping run."
                     )
-                    break
+            else:
+                _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None)
+                if _max_rt:
+                    _wall_elapsed = time.time() - self.agg_start_time_ts
+                    if _wall_elapsed >= float(_max_rt):
+                        self._work_done = True
+                        logger.info(
+                            f"max_experiment_runtime_s={_max_rt}s reached "
+                            f"(wall_elapsed={_wall_elapsed:.0f}s) at round {self._round}; "
+                            f"stopping run."
+                        )
+                        return
+                time.sleep(0.5)
+            return
 
-        # Now perform the actual selection
+        # Threshold met — proceed with selection.
         selected_ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform)
-        
-        if not selected_ends or len(selected_ends) == 0:
-            logger.error(
-                f"[DISTRIBUTE] Round {self._round}: No trainers selected! "
-                f"Cannot proceed with weight distribution."
-            )
+        if not selected_ends:
             return
-        
+
         logger.info(
-            f"[DISTRIBUTE] Round {self._round}: Selected {len(selected_ends)} trainers. "
-            f"Will aggregate when {min(aggr_num, len(selected_ends))} updates received."
+            f"[DISTRIBUTE] Round {self._round}: selected {len(selected_ends)} trainers "
+            f"(eligible={num_eligible}, desired={desired_selection})"
         )
 
         # Same model goes to every recipient this round; build + serialize once.
@@ -772,6 +842,10 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         }
         if self.simulated:
             msg[MessageType.SIM_SEND_TS] = _sim_send_ts
+        else:
+            # T3.0: broadcast the trace-read origin so a trainer's own wall-clock
+            # availability lookups anchor to the SAME point the aggregator uses.
+            msg[MessageType.AGG_START_TS] = self.agg_start_time_ts
         _payload = channel.dumps(msg)
         _send_t0 = time.time()
         for end in selected_ends:
diff --git a/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py b/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py
index a134d5f19..8423004d2 100644
--- a/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py
+++ b/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py
@@ -1577,7 +1577,7 @@ def check_trainer_availability(self, end: str) -> bool:
         if self.track_trainer_avail["enabled"] == "False":
             return True
         elif self.track_trainer_avail["type"] == "ORACULAR":
-            picked_trainer_is_available = self.oracular_trainer_avail_check(end)
+            picked_trainer_is_available = self._trace_read_avail_check(end)
         elif self.track_trainer_avail["type"] == "HEARTBEAT":
             picked_trainer_is_available = self.hearbeat_trainer_avail_check(end)
 
diff --git a/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py b/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py
index e062923bb..95a1c0066 100644
--- a/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py
+++ b/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py
@@ -24,6 +24,7 @@
 import numpy as np
 
 from diskcache import Cache
+from flame.availability.client_availability import ClientAvailability
 from flame.channel_manager import ChannelManager
 from flame.common.constants import DeviceType
 from flame.common.custom_abcmeta import ABCMeta, abstract_attribute
@@ -98,7 +99,7 @@ def reset(self, *args, **kwargs):
 MIN_TRAINERS_JOIN_TIMEOUT_S = 180
 
 
-class TopAggregator(Role, metaclass=ABCMeta):
+class TopAggregator(ClientAvailability, Role, metaclass=ABCMeta):
     """Top level Aggregator implements an ML aggregation role."""
 
     @abstract_attribute
@@ -182,7 +183,7 @@ def internal_init(self) -> None:
 
         # Target-accuracy stopping: count consecutive evals at/above the target
         # test accuracy; stop once we reach `stable_evals_above_target`. Reset on
-        # any dip. `rounds`/`max_runtime_s` remain the safety cap.
+        # any dip. `rounds`/`max_experiment_runtime_s` remain the safety cap.
         self._target_accuracy = getattr(
             self.config.hyperparameters, "target_accuracy", None
         )
@@ -217,6 +218,16 @@ def internal_init(self) -> None:
         self._trainers_used_in_curr_round = []
         self.agg_start_time_ts = time.time()
 
+        # Initialize availability substrate (ClientAvailability). Sets
+        # trainer_event_dict=None when sim_unavailability=False → no-op on
+        # all current runs; gate-on enables the oracular trace-read path.
+        self._init_availability(self.config)
+
+        # E.1: shared sim reorder buffer for withheld-update re-injection
+        # (mirrors asyncfl's _sim_buffer; stays empty when gate is off).
+        self._sim_buffer = SimReorderBuffer()
+        self._sim_committed: set = set()
+
         self._updates_recevied = {}
 
         self._agg_training_stats = {}
@@ -356,7 +367,18 @@ def _sync_sim_recv_first_k(self, channel, ends, first_k):
 
         Sync aggregation is order-independent (weighted average), so parity only
         requires the right *set* of k committers and the round duration.
+
+        E.1: applies the availability send-gate (_sim_withhold_if_unavail) to
+        each popped update so trainers that went UN_AVL before their completion
+        have their update held and delivered stale at delivery_ts. After the
+        first_k barrier loop, drains _sim_buffer for any withheld updates now
+        due (re-injected stale bonus; E.2 accept-stale for feddance/FedAvg).
+        Gate off (trainer_event_dict=None) ⇒ byte-identical to prior behaviour.
         """
+        # E.1: re-inject withheld updates whose delivery_ts ≤ current vclock
+        # into self._sim_buffer (no-op when gate is off).
+        self._sim_reinject_ready_withheld()
+
         # Barrier: drain the whole selected set in one recv_fifo pass, then pick
         # the first_k smallest sim_completion_ts (never before a smaller is in).
         buf = SimReorderBuffer()
@@ -382,19 +404,27 @@ def _sync_sim_recv_first_k(self, channel, ends, first_k):
                 f"buf_depth={len(buf)}"
             )
 
-        committed = []
-        for _ in range(min(first_k, len(buf))):
-            popped = buf.pop_min()
-            if popped is None:
+        # Drain buf (fresh updates from current cohort), applying the send-gate.
+        # Pop smallest-sct first; try to fill first_k even when some are withheld.
+        all_popped = []
+        while True:
+            p = buf.pop_min()
+            if p is None:
                 break
-            end, sct, (msg, md) = popped
-            # Lazy deserialize: trainer pre-serialized weights as raw bytes so
-            # N-K non-committed messages didn't pay tensor-reconstruction cost.
-            # Reconstruct only for this committed update.
+            all_popped.append(p)
+
+        committed = []
+        for end, sct, (msg, md) in all_popped:
+            # Lazy deserialize before gate check (payload may be needed for stash).
             if MessageType.WEIGHTS_BYTES in msg:
                 msg[MessageType.WEIGHTS] = cloudpickle.loads(
                     msg.pop(MessageType.WEIGHTS_BYTES)
                 )
+            # E.1: send-gate — withhold if trainer is UN_AVL at completion.
+            if self._sim_withhold_if_unavail(channel, end, sct, (msg, md)):
+                continue
+            if len(committed) >= first_k:
+                break  # first_k quota met; remaining straggler updates dropped
             self._advance_sim_clock(sct)
             _sst = channel.get_end_property(end, PROP_SIM_SEND_TS)
             _srd = msg.get(MessageType.SIM_CLIENT_TASK_TRAIN_DURATION_S)
@@ -409,6 +439,34 @@ def _sync_sim_recv_first_k(self, channel, ends, first_k):
                 f"T_v={self._vclock.now:.1f}"
             )
             committed.append((msg, md))
+
+        # E.1 / E.2: drain withheld-delivery bonus. After the barrier advances the
+        # clock, re-inject any newly-due entries, then commit them as stale bonus
+        # updates (accept-stale; no new scalar — E.2 for feddance/FedAvg).
+        self._sim_reinject_ready_withheld()
+        while True:
+            wh = self._sim_buffer.pop_min()
+            if wh is None:
+                break
+            wend, wdts, (wmsg, wmd) = wh
+            if MessageType.WEIGHTS_BYTES in wmsg:
+                wmsg[MessageType.WEIGHTS] = cloudpickle.loads(
+                    wmsg.pop(MessageType.WEIGHTS_BYTES)
+                )
+            # Batch 3 T3.5 (K11): advance before emitting, matching asyncfl's
+            # existing order — see _emit_withheld_delivery's docstring for why
+            # this specific advance is provably a no-op here either way, but
+            # the uniform ordering is kept as a defensive rule across stacks.
+            _wd = self._sim_take_withheld_delivering(wend)
+            self._advance_sim_clock(wdts)
+            if _wd is not None:
+                self._emit_withheld_delivery(wend, wmsg, _wd[0], _wd[1])
+            logger.info(
+                f"[SYNC_WITHHELD_DELIVER] end={str(wend)[-4:]} "
+                f"delivery_ts={wdts:.1f} T_v={self._vclock.now:.1f}"
+            )
+            committed.append((wmsg, wmd))
+
         return committed
 
     @staticmethod
@@ -484,7 +542,33 @@ def _aggregate_weights(self, tag: str) -> None:
             _resolved_k = first_k if first_k > 0 else len(ends)
             updates = self._sync_sim_recv_first_k(channel, ends, _resolved_k)
         else:
-            updates = channel.recv_fifo(ends, first_k=first_k)
+            # B2.0.1 / Challenge 16: bound the real recv barrier with a wall-clock
+            # timeout. The sync barrier waits for first_k=agg_goal of the selected
+            # set; under unavailability the withheld trainers never send, so an
+            # un-timed recv_fifo blocks forever (the feddance n=12 real hang: round
+            # 1 dispatched 12, ~6 withheld, recv_fifo stalled on the 10th for 46
+            # min until the watchdog killed it). Mirror the oort real-recv timeout
+            # and the sim 90s vclock abandon: wait up to trainer_recv_wall_timeout_s
+            # (default 90s, >> the ~18s max trainer compute, so live stragglers
+            # still land) per next message, capped at the remaining experiment
+            # budget so the round proceeds with whatever arrived and
+            # increment_round's budget check can then fire. WALL-CLOCK only; sim
+            # path is unchanged. Harmless with the gate OFF — all first_k arrive
+            # well within the timeout, so recv_fifo returns before it triggers.
+            _stall = float(getattr(
+                self.config.hyperparameters, "trainer_recv_wall_timeout_s", 90.0
+            ))
+            _max_rt = getattr(
+                self.config.hyperparameters, "max_experiment_runtime_s", None
+            )
+            if _max_rt:
+                _remaining = max(
+                    1.0, float(_max_rt) - (time.time() - self.agg_start_time_ts)
+                )
+                _recv_timeout = min(_stall, _remaining)
+            else:
+                _recv_timeout = _stall
+            updates = channel.recv_fifo(ends, first_k=first_k, timeout=_recv_timeout)
 
         # receive local model parameters from trainers
         # [U6 real barrier-anchor] Real applies all K updates at ONE post-loop
@@ -499,6 +583,11 @@ def _aggregate_weights(self, tag: str) -> None:
                 logger.debug(f"No data from {end}; skipping it")
                 continue
 
+            # T3.3 commit-checkpoint belief (real mode only — sim's own commit
+            # loop already recorded it inside _sim_withhold_if_unavail).
+            if not self.simulated:
+                self._record_commit_belief(end)
+
             logger.debug(f"received data from {end}")
             channel.set_end_property(end, PROP_ROUND_END_TIME, (round, timestamp))
 
@@ -741,6 +830,23 @@ def put(self, tag: str, task_to_perform: str = "train") -> None:
             self.dist_tag = tag
             self._distribute_weights(tag, task_to_perform)
 
+    def _mark_join_barrier_done(self) -> None:
+        """Latch the one-shot join barrier and re-anchor the real-mode trace-read
+        origin to "now" (round-0 start), not aggregator __init__.
+
+        `agg_start_time_ts` is stamped at __init__, before the join wait runs.
+        Sim is unaffected (`_avail_now()` reads `_vclock.now`, which only
+        starts advancing at round-0 selection). Real reads `time.time() -
+        agg_start_time_ts`, so without this re-anchor the join wait (~300s
+        wall at n=300, real OS process spawn/connect) is silently baked into
+        every trace read -- real ends up ~300s ahead of sim/ground-truth (see
+        UNAVAILABILITY_DESIGN.md's B2.0.3). Self-correcting to however long
+        the join actually takes.
+        """
+        self._join_barrier_done = True
+        if not self.simulated:
+            self.agg_start_time_ts = time.time()
+
     def _await_min_trainers(self, channel) -> None:
         """One-shot startup barrier: block until ``min_trainers_to_start`` ends
         have joined the channel before the first selection.
@@ -759,7 +865,7 @@ def _await_min_trainers(self, channel) -> None:
             return
         min_start = getattr(self.config.hyperparameters, "min_trainers_to_start", None)
         if not min_start or int(min_start) <= 0:
-            self._join_barrier_done = True
+            self._mark_join_barrier_done()
             return
         min_start = int(min_start)
         # Allow override: large cohorts (e.g. n300 at sleep_between_spawns=1s take
@@ -772,7 +878,7 @@ def _await_min_trainers(self, channel) -> None:
             n = len(channel._ends)
             if n >= min_start:
                 logger.info(f"[JOIN_BARRIER] {n}/{min_start} trainers joined; starting")
-                self._join_barrier_done = True
+                self._mark_join_barrier_done()
                 return
             logger.info(f"[JOIN_BARRIER] waiting for {min_start} trainers to join; have {n}")
             time.sleep(1.0)
@@ -780,7 +886,7 @@ def _await_min_trainers(self, channel) -> None:
             f"[JOIN_BARRIER] timed out after {timeout_s:.0f}s; "
             f"proceeding with {len(channel._ends)}/{min_start} trainers"
         )
-        self._join_barrier_done = True
+        self._mark_join_barrier_done()
 
     @timer_decorator
     def _inject_oracle_utilities(self, channel, task_to_perform: str) -> None:
@@ -812,22 +918,129 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         # before distributing weights, update it from global model
         self._update_weights()
 
+        # E.1: re-clock the 90s abandon to the vclock and free stalled slots so a
+        # replacement is selectable this round (no-op when the gate is off).
+        # Sim-only: real mode already has a native wall-clock abandon in the
+        # selector itself (SEND_TIMEOUT_WAIT_S), so this would be redundant there.
+        if self.simulated:
+            self._sim_abandon_stalled(channel)
+        # D.1: for availability_aware baselines, proactively free any in-flight
+        # slot the trace now shows as UN_AVL -- no 90s wait. Both modes: trace-read
+        # eviction has no real-mode equivalent (unlike the abandon above), so
+        # gating it sim-only left real-mode felix runs with no way to drop a
+        # stalled UN_AVL trainer from recv_ends (see Batch 4 finding 1,
+        # UNAVAILABILITY_DESIGN.md). No-op here (refl/feddance's
+        # proactive_inflight_evict is False), kept for symmetry with asyncfl.
+        self._sim_evict_unavail_inflight(channel)
+
+        # E.1: oracular gate — build the unavailability list for this selection.
+        if self.trainer_event_dict is not None:
+            curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers(
+                task_to_perform
+            )
+            # invariant 2: a trainer with a withheld update stays out of the
+            # eligible pool until its delivery_ts.
+            _held_withheld = self.withheld_held_ends()
+            if _held_withheld:
+                curr_unavail_trainer_list = list(
+                    set(curr_unavail_trainer_list) | _held_withheld
+                )
+        else:
+            curr_unavail_trainer_list = []
+        channel.set_curr_unavailable_trainers(
+            trainer_unavail_list=curr_unavail_trainer_list
+        )
+        # Stamp PROP_AVL_STATE so emit_selection's avail_composition/per_trainer
+        # reflect the oracular read instead of staying all-UNKNOWN.
+        self._avail_stamp_end_states(channel)
+
         # Per-baseline online oracle: overwrite candidate stat-utility with the
         # TRUE current value (computed from the just-updated global model) before
         # the selector ranks. No-op unless oracle_utility_injection is enabled.
         self._inject_oracle_utilities(channel, task_to_perform)
 
+        # Expose current availability-timeline time to selector so it can attach
+        # it to selection events (C.6.1 — mirrors the same exposure in
+        # oort/asyncfl top_aggregators). _avail_now() covers both modes (sim
+        # vclock / real wall-elapsed-since-agg_start) — real used to be skipped
+        # here, leaving real selection events with no shared time-base and
+        # forcing parity's A4dur to fall back to a wrong, join-ramp-skewed
+        # origin (ts of first selection event, not agg_start).
+        channel.properties["vclock_now"] = self._avail_now()
+
         logger.debug(
             f"Sending weights to trainers with task_to_perform = {task_to_perform}"
         )
+
+        # F.2: Pre-selection threshold check — return-early if pool is scarce.
+        # Threshold = agg_goal: sync FL must have exactly agg_goal eligible trainers
+        # before starting a round. Random selector (fwdllm syncfl) uses this same
+        # aggregator; the pre-selection threshold ensures it is never called with
+        # fewer than agg_goal eligible trainers.
+        _agg_goal = self.config.hyperparameters.aggregation_goal
+        _threshold = _agg_goal if _agg_goal and _agg_goal > 0 else 1
+        _in_flight = getattr(channel._selector, 'selected_ends', set())
+        if not isinstance(_in_flight, set):
+            _in_flight = set(_in_flight) if _in_flight else set()
+        num_eligible = len(
+            set(channel._ends.keys()) - set(curr_unavail_trainer_list) - _in_flight
+        )
+
+        if num_eligible < _threshold:
+            if self.simulated and self.trainer_event_dict is not None:
+                _nxt = self._next_avail_vclock()
+                _budget = float(
+                    getattr(self.config.hyperparameters, "max_experiment_runtime_s", float("inf"))
+                )
+                if _nxt is not None and _nxt > self._vclock.now and self._vclock.now < _budget:
+                    self._vclock.advance(_nxt)
+                    self._sim_abandon_stalled(channel)
+                    curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers(
+                        task_to_perform
+                    )
+                    _held = self.withheld_held_ends()
+                    if _held:
+                        curr_unavail_trainer_list = list(
+                            set(curr_unavail_trainer_list) | _held
+                        )
+                    channel.set_curr_unavailable_trainers(
+                        trainer_unavail_list=curr_unavail_trainer_list
+                    )
+                    self._avail_stamp_end_states(channel)
+                    channel.properties["vclock_now"] = self._vclock.now
+                    logger.info(
+                        f"[SIM_STARVATION] round={self._round} eligible={num_eligible} "
+                        f"< {_threshold}; vclock→{_nxt}"
+                    )
+                else:
+                    # Trace horizon or budget reached — stop instead of spinning.
+                    self._work_done = True
+                    logger.info(
+                        f"[SIM_STARVATION] trace horizon or budget reached at "
+                        f"vclock={self._vclock.now:.1f}s (nxt={_nxt}, "
+                        f"budget={_budget:.0f}s, round={self._round}); stopping run."
+                    )
+            else:
+                _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None)
+                if _max_rt:
+                    _wall_elapsed = time.time() - self.agg_start_time_ts
+                    if _wall_elapsed >= float(_max_rt):
+                        self._work_done = True
+                        logger.info(
+                            f"max_experiment_runtime_s={_max_rt}s reached "
+                            f"(wall_elapsed={_wall_elapsed:.0f}s) at round {self._round}; "
+                            f"stopping run."
+                        )
+                        return
+                time.sleep(0.5)
+            return
+
+        # Threshold met — proceed with selection.
         # SEND state: pick (new) trainers to send the model to. With a buffered
         # selector (random) this fills concurrency; stateless selectors ignore
         # the state and return their normal selection.
         selected_ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform)
         if not selected_ends:
-            # ends() can be None/empty before trainers join + get selected
-            # (notably in simulated mode where the loop spins without sleeps).
-            time.sleep(0.5)
             return
         datasampler_metadata = self.datasampler.get_metadata(self._round, selected_ends)
 
@@ -842,6 +1055,11 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None:
         }
         if self.simulated:
             msg[MessageType.SIM_SEND_TS] = _sim_send_ts
+        else:
+            # T3.0: broadcast the trace-read origin so a trainer's own wall-clock
+            # availability lookups anchor to the SAME point the aggregator uses
+            # (post-join-barrier-reanchor), not a per-trainer local origin.
+            msg[MessageType.AGG_START_TS] = self.agg_start_time_ts
         _payload = channel.dumps(msg)
         _send_t0 = time.time()  # [DISTRIBUTE_TIMING]
         for end in selected_ends:
@@ -869,7 +1087,18 @@ def inform_end_of_training(self) -> None:
             logger.debug(f"channel not found for tag {self.dist_tag}")
             return
 
-        channel.broadcast({MessageType.EOT: self._work_done})
+        payload = {MessageType.EOT: self._work_done}
+        # Sim trainers only advance _sim_now() on dispatch, so one that goes
+        # quiet (withheld/evicted UN_AVL) never catches its avl_state up to
+        # later trace transitions (UNAVAILABILITY_DESIGN.md's Batch 4 finding
+        # 2). Piggyback the final vclock on this broadcast (reaches every
+        # connected end regardless of dispatch state) as a last wake-up for
+        # _refresh_avl_state() to flush queued transitions before exit. Gated
+        # on the availability feature (byte-identical broadcast payload when
+        # off); real mode's clock never freezes, so it doesn't need this.
+        if self.simulated and getattr(self, "trainer_event_dict", None) is not None:
+            payload[MessageType.SIM_SEND_TS] = self._avail_now()
+        channel.broadcast(payload)
         logger.debug("done broadcasting end-of-training")
 
     def run_analysis(self):
@@ -908,14 +1137,16 @@ def increment_round(self):
         self._round += 1
         self._work_done = self._round > self._rounds
 
-        # Optional runtime cap: stop once max_runtime_s has elapsed.
-        # In simulated mode use the virtual clock (vclock_now = simulated seconds
-        # elapsed) so the run covers max_runtime_s of *virtual* time, not wall
-        # time. In real mode use wall-clock elapsed.
-        _max_rt = getattr(self.config.hyperparameters, "max_runtime_s", None)
+        # Optional runtime cap: stop once max_experiment_runtime_s has elapsed.
+        # Clock interpretation is mode-dependent:
+        #   real mode  → wall-clock seconds (time.time() elapsed)
+        #   sim mode   → virtual-clock seconds (vclock.now)
+        # This lets one YAML value govern both modes: the same 1800s means
+        # "30 wall-clock minutes" in real and "1800 virtual seconds" in sim.
+        _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None)
         # sim_wall_ceiling_s: tight wall-clock guard for sim mode (iii-b).
-        # A sim run should finish in <= max_runtime_s wall (it runs faster than
-        # real when the parity bug is fixed). Default = max_runtime_s (1×).
+        # A sim run should finish in <= max_experiment_runtime_s wall (it runs
+        # faster than real when the parity bug is fixed). Default = 1× budget.
         # Separate from max_wall_runtime_s (kept for backward compat, used as
         # secondary fallback if sim_wall_ceiling_s is absent).
         _sim_wall_ceil = getattr(self.config.hyperparameters, "sim_wall_ceiling_s", None)
@@ -927,15 +1158,15 @@ def increment_round(self):
             else:
                 elapsed = time.time() - self.agg_start_time_ts
                 clock_label = "wall"
-            if elapsed > float(_max_rt):
+            if elapsed >= float(_max_rt):
                 logger.info(
-                    f"max_runtime_s={_max_rt}s reached ({clock_label}_elapsed={elapsed:.0f}s) "
+                    f"max_experiment_runtime_s={_max_rt}s reached ({clock_label}_elapsed={elapsed:.0f}s) "
                     f"at round {self._round}; stopping run."
                 )
                 self._work_done = True
             # Failsafe: in sim mode the primary check is virtual time.
-            # sim_wall_ceiling_s (default = max_runtime_s = 1×) caps the wall time
-            # a sim may use — a well-behaved sim finishes in ≤ real-mode wall time.
+            # sim_wall_ceiling_s (default = max_experiment_runtime_s × 1) caps the
+            # wall time a sim may use — well-behaved sim finishes in ≤ real wall time.
             if self.simulated and not self._work_done:
                 _wall_elapsed = time.time() - self.agg_start_time_ts
                 if _sim_wall_ceil:
@@ -948,7 +1179,7 @@ def increment_round(self):
                     logger.warning(
                         f"[SIM_WALL_CEILING] sim_wall_ceiling={_failsafe_s:.0f}s reached "
                         f"(wall_elapsed={_wall_elapsed:.0f}s, "
-                        f"vclock={self._vclock.now:.0f}s, max_runtime_s={_max_rt}s) "
+                        f"vclock={self._vclock.now:.0f}s, max_experiment_runtime_s={_max_rt}s) "
                         f"at round {self._round}. "
                         f"Sim is slower than real — investigate per-round parity (bug iii-c). "
                         f"Stopping run."
@@ -1160,67 +1391,6 @@ def _update_weights(self):
         elif self.framework == MLFramework.TENSORFLOW:
             self.weights = self.model.get_weights()
 
-    def get_curr_unavail_trainers(self) -> list:
-        curr_unavail_trainer_list = []
-
-        # Ensure trainer_event_dict exists
-        if self.trainer_event_dict is not None:
-            # Aggregator time since start, on the SAME timeline the trace's event
-            # timestamps live on. In simulated mode that is the virtual clock
-            # (sim-seconds); wall-clock would be a few seconds total while the
-            # virtual timeline spans the whole trace, making every window look
-            # available. Trainer-side availability already keys off _sim_now()
-            # (sim_send_ts); this mirrors it for the aggregator-side oracular path.
-            agg_time_since_start_s = (
-                self._vclock.now if self.simulated
-                else time.time() - self.agg_start_time_ts
-            )
-
-            for trainer_id, event_dict in list(self.trainer_event_dict.items()):
-                logger.debug(
-                    f"Checking trainer {trainer_id}'s availability. Event_dict is: {event_dict}"
-                )
-
-                if not event_dict:
-                    continue  # Skip if no events for trainer
-
-                # Binary search for closest past event
-                idx = event_dict.bisect_right(agg_time_since_start_s) - 1
-                logger.debug(f"Trainer_id: {trainer_id} got index: {idx}")
-
-                if idx >= 0:
-                    most_recent_event = event_dict.peekitem(idx)
-                    logger.debug(
-                        f"Trainer_id: {trainer_id} got most_recent_event: {most_recent_event}"
-                    )
-
-                    most_recent_event_ts = most_recent_event[0]
-                    most_recent_event_state = most_recent_event[1]
-
-                    if most_recent_event_state == "UN_AVL":
-                        logger.debug(
-                            f"Trainer {trainer_id} is unavailable since time {most_recent_event_ts}."
-                        )
-                        curr_unavail_trainer_list.append(trainer_id)
-                    elif most_recent_event_state == "AVL_TRAIN":
-                        logger.debug(
-                            f"Trainer {trainer_id} is available since time {most_recent_event_ts}."
-                        )
-                    else:
-                        logger.warning(
-                            f"Trainer {trainer_id} was in state {most_recent_event_state} since time {most_recent_event_ts}, needs to be handled."
-                        )
-
-                # TODO: To be more memory efficient, we can delete
-                # events that are way past their time and already used
-
-        # Return the list of currently unavailable trainers
-        logger.debug(
-            f"Current curr_unavail_trainer_list: {curr_unavail_trainer_list} has {len(curr_unavail_trainer_list)} ends out of total {len(self.trainer_event_dict)} ends dict"
-        )
-
-        return curr_unavail_trainer_list
-
     def compose(self) -> None:
         """Compose role with tasklets."""
 
diff --git a/lib/python/flame/mode/horizontal/syncfl/trainer.py b/lib/python/flame/mode/horizontal/syncfl/trainer.py
index 53fb2c541..ef06afce0 100644
--- a/lib/python/flame/mode/horizontal/syncfl/trainer.py
+++ b/lib/python/flame/mode/horizontal/syncfl/trainer.py
@@ -256,6 +256,14 @@ def _fetch_weights(self, tag: str) -> None:
         if MessageType.SIM_SEND_TS in msg:
             self._sim_send_ts = msg[MessageType.SIM_SEND_TS]
 
+        # Cache the aggregator's trace-read origin (real mode only) so this
+        # trainer's own wall-clock availability lookups share the exact
+        # origin the aggregator uses, instead of deriving one from its own
+        # process-start time. Re-cached every dispatch (cheap, idempotent,
+        # self-healing if an early message was missed).
+        if MessageType.AGG_START_TS in msg:
+            self._agg_start_origin = msg[MessageType.AGG_START_TS]
+
         if telemetry.is_enabled():
             _sim_send_ts_val = getattr(self, "_sim_send_ts", None)
             _time_mode = getattr(self, "time_mode", "real")
@@ -271,6 +279,13 @@ def _fetch_weights(self, tag: str) -> None:
 
         if MessageType.EOT in msg:
             self._work_done = msg[MessageType.EOT]
+            # Give a sim-mode trainer that hasn't been dispatched in a while
+            # one last chance to catch its avl_state/telemetry up to the
+            # trace, using the SIM_SEND_TS this EOT broadcast may carry
+            # (captured above). hasattr-guarded: example-specific hook, not
+            # every Trainer subclass defines it.
+            if hasattr(self, "_refresh_avl_state"):
+                self._refresh_avl_state()
 
         if MessageType.DATASAMPLER_METADATA in msg:
             self.datasampler.handle_metadata_from_aggregator(
@@ -344,20 +359,34 @@ def _send_weights(self, tag: str) -> None:
             f"### SEND WEIGHTS for tag: {tag} "
             f"and trainer_id: {self.trainer_id}, model_version: {self._round}, and avl_state = {self.avl_state}"
         )
-        # if switch to do three_state_avl is on and the trainer is
-        # unavailable - check the wait_to_become_avl switch depending
-        # on the switch we decide whether to wait for availability or
-        # exit
+        # [SEND_GATE] real-mode send-time gate: hold the upload (already-
+        # completed result) until the trainer is AVL_* again. Decoupled from
+        # client_notify["enabled"] (v1 keeps it OFF -- the aggregator learns
+        # oracularly, not via this push). Sim-only is a no-op here since sim
+        # time can't advance while blocked on time.sleep -- sim availability
+        # is instead enforced agg-side by ClientAvailability's send-time
+        # withhold, keyed on the trainer-reported completion time.
+        #
+        # Sample send_gate_sct (trainer's own trace-time clock) right before
+        # the gate check regardless of whether it engages, so A8 can confirm
+        # the no-wait case too. Real mode only; hasattr-guarded since
+        # _sim_now() is example-specific, not on this generic base class.
+        _send_gate_sct = (
+            self._sim_now()
+            if not getattr(self, "simulated", False) and hasattr(self, "_sim_now")
+            else None
+        )
         if (
-            self.client_notify["enabled"] == "True"
+            not getattr(self, "simulated", False)
             and self.avl_state == TrainerAvailState.UN_AVL
         ):
             if self.wait_until_next_avl == "True":
                 logger.warning(
                     f"Trainer id {self.trainer_id} is unavailable to send weights. Waiting for it to be available again"
                 )
-                while self.avl_state == TrainerAvailState.UN_AVL:
-                    time.sleep(1)
+                with self._phase("send_gate_wait_s"):
+                    while self.avl_state == TrainerAvailState.UN_AVL:
+                        time.sleep(1)
             else:
                 logger.warning(
                     f"Trainer id {self.trainer_id} is unavailable to send weights since wait_until_next_avl = {self.wait_until_next_avl}. Exiting sending weights."
@@ -467,6 +496,12 @@ def _send_weights(self, tag: str) -> None:
                 wall_recv_ts=getattr(self, "_wall_recv_ts", None),
                 wall_send_ts=_wall_send_ts,
                 time_mode=getattr(self, "time_mode", "real"),
+                send_gate_wait_s=(
+                    float(self._phase_times.get("send_gate_wait_s", 0.0))
+                    if not getattr(self, "simulated", False)
+                    else None
+                ),
+                send_gate_sct=_send_gate_sct,
             )
             telemetry.emit(ev, **fields)
 
diff --git a/lib/python/flame/mode/message.py b/lib/python/flame/mode/message.py
index 3afa1b721..89d1ac8bf 100644
--- a/lib/python/flame/mode/message.py
+++ b/lib/python/flame/mode/message.py
@@ -87,3 +87,12 @@ class MessageType(Enum):
     WALL_RECV_TS = 39        # wall-clock unix timestamp (float) when trainer's channel.recv() returns (weights received from agg)
     CLIENT_TASK_TRAIN_COMPUTE_S = 40     # modeled compute duration in seconds: max(real_gpu_time, training_delay_s); stamped by trainer unconditionally (real and sim)
     WEIGHTS_BYTES = 41       # pre-serialized weights (raw cloudpickle bytes) for lazy sync-barrier deserialization in sim mode
+
+    # Real-mode-only counterpart to SIM_SEND_TS: the aggregator's own
+    # availability trace-read origin (agg_start_time_ts, re-anchored at
+    # join-barrier resolution, see _mark_join_barrier_done()), broadcast on
+    # every dispatch so a trainer's own wall-clock trace lookups share the
+    # aggregator's exact origin instead of deriving their own (join-ramp
+    # skew, same class of bug as B2.0.3). Sim mode never sends this -- its
+    # shared origin is the single _vclock, already exposed via SIM_SEND_TS.
+    AGG_START_TS = 42
diff --git a/lib/python/flame/plugin/__init__.py b/lib/python/flame/plugin/__init__.py
index 26967b4d1..55b6ad9f7 100644
--- a/lib/python/flame/plugin/__init__.py
+++ b/lib/python/flame/plugin/__init__.py
@@ -55,7 +55,7 @@ def __init__(self, plugins_path: str = "/etc/flame/plugin") -> None:
                 cls_name, package, ptype = self.parse_plugin(filepath)
                 self.register_plugin(cls_name, package, ptype)
         except FileNotFoundError as e:
-            logger.warn(f"{e.filename} not found; stop plugin registration.")
+            logger.warning(f"{e.filename} not found; stop plugin registration.")
             return
 
     def parse_plugin(self, filepath: str) -> Tuple[str, str, PluginType]:
diff --git a/lib/python/flame/selector/__init__.py b/lib/python/flame/selector/__init__.py
index dbbd9d8db..8177b1ad6 100644
--- a/lib/python/flame/selector/__init__.py
+++ b/lib/python/flame/selector/__init__.py
@@ -142,6 +142,7 @@ def emit_selection(
                     if hasattr(speed, "total_seconds")
                     else speed,
                     "selected": end_id in chosen_set,
+                    "avl_state": state_name,
                 }
                 if per_trainer_extra and end_id in per_trainer_extra:
                     entry.update(per_trainer_extra[end_id])
diff --git a/lib/python/flame/selector/async_oort.py b/lib/python/flame/selector/async_oort.py
index 6b0b23f4f..c14bbe030 100644
--- a/lib/python/flame/selector/async_oort.py
+++ b/lib/python/flame/selector/async_oort.py
@@ -361,6 +361,7 @@ def select(
                 task_to_perform=task_to_perform,
                 agg_version_state=agg_version_state,
                 trainer_version_states=trainer_version_states,
+                connected_ends=ends,  # Challenge 13: full pool for cleanup
             )
 
             if len(results) is not 0:
@@ -1400,6 +1401,7 @@ def _handle_send_state(
         task_to_perform: str = "train",
         agg_version_state=None,  # (model_version, data_id, iteration_id)
         trainer_version_states: dict[str, tuple[int, int, int]] = None,
+        connected_ends: dict[str, End] = None,
     ) -> SelectorReturnType:
         selected_ends = self.selected_ends[self.requester]
         logger.debug(
@@ -1481,9 +1483,16 @@ def _handle_send_state(
                         del self.all_selected[end]
                     selected_ends.discard(end)
 
+        # Challenge 13: cleanup must check CONNECTED membership, not availability-
+        # eligibility — an in-flight trainer that merely went UN_AVL (or is the
+        # wrong task-type) is absent from the filtered `ends` but still connected;
+        # removing it makes the aggregator forget it is waiting. An empty eligible
+        # pool would otherwise wipe ALL shared selected_ends → hang. Use the full
+        # connected pool when provided; fall back to `ends` for backward compat.
+        _connected = connected_ends if connected_ends is not None else ends
         # Check for invalid selections and remove them
         for end_id in list(selected_ends):
-            if end_id not in ends:
+            if end_id not in _connected:
                 # something happened to end of end_id (e.g.,
                 # connection loss) let's remove it from selected_ends
                 # so that you can fill that spot with another trainer
diff --git a/lib/python/flame/selector/async_random.py b/lib/python/flame/selector/async_random.py
index c894cf844..40fb955e6 100644
--- a/lib/python/flame/selector/async_random.py
+++ b/lib/python/flame/selector/async_random.py
@@ -197,6 +197,7 @@ def select(
                 task_to_perform=task_to_perform,
                 agg_version_state=agg_version_state,
                 trainer_version_states=trainer_version_states,
+                connected_ends=ends,  # Challenge 13: full pool for cleanup
             )
 
             if len(results) is not 0:
@@ -460,6 +461,7 @@ def _handle_send_state(
         task_to_perform: str = "train",
         agg_version_state=None,  # (model_version, data_id, iteration_id)
         trainer_version_states: dict[str, tuple[int, int, int]] = None,
+        connected_ends: dict[str, End] = None,
     ) -> SelectorReturnType:
         selected_ends = self.selected_ends[self.requester]
         logger.debug(f"Inside handle send state: aggregator version state {agg_version_state}")
@@ -534,9 +536,16 @@ def _handle_send_state(
                         del self.all_selected[end]
                     selected_ends.discard(end)
 
+        # Challenge 13: cleanup must check CONNECTED membership, not availability-
+        # eligibility — an in-flight trainer that merely went UN_AVL (or is the
+        # wrong task-type) is absent from the filtered `ends` but still connected;
+        # removing it makes the aggregator forget it is waiting. An empty eligible
+        # pool would otherwise wipe ALL shared selected_ends → hang. Use the full
+        # connected pool when provided; fall back to `ends` for backward compat.
+        _connected = connected_ends if connected_ends is not None else ends
         # Check for invalid selections and remove them
         for end_id in list(selected_ends):
-            if end_id not in ends:
+            if end_id not in _connected:
                 # something happened to end of end_id (e.g.,
                 # connection loss) let's remove it from selected_ends
                 # so that you can fill that spot with another trainer
diff --git a/lib/python/flame/selector/fedbuff.py b/lib/python/flame/selector/fedbuff.py
index 63759b268..02e677cc7 100644
--- a/lib/python/flame/selector/fedbuff.py
+++ b/lib/python/flame/selector/fedbuff.py
@@ -195,14 +195,17 @@ def select(
 
         results = {}
         if channel_props[KEY_CH_STATE] == VAL_CH_STATE_SEND:
-            results = self._handle_send_state(eligible_ends, concurrency)
+            results = self._handle_send_state(
+                eligible_ends, concurrency, connected_ends=ends
+            )  # Challenge 13: full pool for cleanup
             self.emit_selection(
                 channel_props.get("round", 0),
                 "train",
                 ends,
                 eligible_ends.keys(),
                 list(results.keys()),
-                extra={"concurrency": concurrency, "requester": self.requester},
+                extra={"concurrency": concurrency, "requester": self.requester,
+                       "vclock_now": channel_props.get("vclock_now")},
             )
 
         elif channel_props[KEY_CH_STATE] == VAL_CH_STATE_RECV:
@@ -440,13 +443,21 @@ def _cleanup_send_ends(self):
                 del self.all_selected[end_id]
 
     def _handle_send_state(
-        self, ends: dict[str, End], concurrency: int
+        self, ends: dict[str, End], concurrency: int,
+        connected_ends: dict[str, End] = None,
     ) -> SelectorReturnType:
         selected_ends = self.selected_ends[self.requester]
 
+        # Challenge 13: cleanup must check CONNECTED membership, not availability-
+        # eligibility — an in-flight trainer that merely went UN_AVL (or is the
+        # wrong task-type) is absent from the filtered `ends` but still connected;
+        # removing it makes the aggregator forget it is waiting. An empty eligible
+        # pool would otherwise wipe ALL shared selected_ends → hang. Use the full
+        # connected pool when provided; fall back to `ends` for backward compat.
+        _connected = connected_ends if connected_ends is not None else ends
         # Check for invalid selections and remove them
         for end_id in list(selected_ends):
-            if end_id not in ends:
+            if end_id not in _connected:
                 # something happened to end of end_id (e.g.,
                 # connection loss) let's remove it from selected_ends
                 # so that you can fill that spot with another trainer
diff --git a/lib/python/flame/selector/feddance.py b/lib/python/flame/selector/feddance.py
index 2040dc1aa..fa4b0cf11 100644
--- a/lib/python/flame/selector/feddance.py
+++ b/lib/python/flame/selector/feddance.py
@@ -161,7 +161,8 @@ def select(
         self.emit_selection(
             round_num, task_to_perform, ends, eligible.keys(), selected,
             per_trainer_extra=ptx,
-            extra={"num_unavail": len(unavail)},
+            extra={"num_unavail": len(unavail),
+                   "vclock_now": channel_props.get("vclock_now")},
         )
         return {key: None for key in selected}
 
diff --git a/lib/python/flame/selector/oort.py b/lib/python/flame/selector/oort.py
index 94447e58d..648a2c851 100644
--- a/lib/python/flame/selector/oort.py
+++ b/lib/python/flame/selector/oort.py
@@ -245,7 +245,9 @@ def select(
             result = self.select_random(ends, num_of_ends)
             self.emit_selection(
                 round, task_to_perform, all_ends, ends.keys(),
-                self.selected_ends, extra={"mode": "random_first_round"},
+                self.selected_ends,
+                extra={"mode": "random_first_round",
+                       "vclock_now": channel_props.get("vclock_now")},
             )
             return result
 
@@ -264,7 +266,9 @@ def select(
             result = self.select_random(ends, num_of_ends)
             self.emit_selection(
                 round, task_to_perform, all_ends, ends.keys(),
-                self.selected_ends, extra={"mode": "random_no_utility"},
+                self.selected_ends,
+                extra={"mode": "random_no_utility",
+                       "vclock_now": channel_props.get("vclock_now")},
             )
             return result
 
@@ -337,6 +341,7 @@ def select(
                 # pacer state: the percentile that sets pref (read pref divergence directly).
                 "round_threshold": getattr(self, "round_threshold", None),
                 "alpha": getattr(self, "alpha", None),
+                "vclock_now": channel_props.get("vclock_now"),
                 # per-round speed-penalty summary over selected (see _system_util_summary)
                 **self._system_util_summary(),
             },
diff --git a/lib/python/flame/selector/refl_oort.py b/lib/python/flame/selector/refl_oort.py
index cd37efc3a..eed01a3fd 100644
--- a/lib/python/flame/selector/refl_oort.py
+++ b/lib/python/flame/selector/refl_oort.py
@@ -232,6 +232,7 @@ def select(
                 "num_priority": len(priority_ends),
                 "num_blacklist": len(blacklist),
                 "exploration_factor": self.exploration_factor,
+                "vclock_now": channel_props.get("vclock_now"),
             },
         )
         return {key: None for key in newly_selected}
diff --git a/lib/python/flame/telemetry/events.py b/lib/python/flame/telemetry/events.py
index fdb23239c..237f09d8c 100644
--- a/lib/python/flame/telemetry/events.py
+++ b/lib/python/flame/telemetry/events.py
@@ -26,6 +26,9 @@
 EVENT_INFLIGHT_RESIDENCE = "inflight_residence"  # per-round in-flight drain accounting (oort sync)
 EVENT_UTILITY_BELIEF = "utility_belief"  # believed (at selection) vs actual (at return) client utility
 EVENT_DISPATCH = "dispatch"          # per-dispatch re-dispatch-stagger validation (felix)
+EVENT_WITHHELD_DELIVERY = "withheld_delivery"  # late stale delivery of a send-gated update
+EVENT_ABANDON_TIMEOUT = "abandon_timeout"      # 90s vclock slot-free of a stalled trainer
+EVENT_AGG_BELIEF_CHANGE = "agg_belief_change"   # aggregator's belief about a trainer's avail state
 
 KNOWN_EVENTS = frozenset(
     {
@@ -40,6 +43,10 @@
         EVENT_TASK_SEND,
         EVENT_INFLIGHT_RESIDENCE,
         EVENT_UTILITY_BELIEF,
+        EVENT_DISPATCH,
+        EVENT_WITHHELD_DELIVERY,
+        EVENT_ABANDON_TIMEOUT,
+        EVENT_AGG_BELIEF_CHANGE,
     }
 )
 
@@ -216,13 +223,28 @@ def build_util_disparity(
 
 
 def build_avail_change(
-    *, round_num: Optional[int], old_state: str, new_state: str
+    *,
+    round_num: Optional[int],
+    old_state: str,
+    new_state: str,
+    sim_now: Optional[float] = None,
 ) -> tuple[str, dict[str, Any]]:
-    """Trainer availability state transition."""
+    """Trainer availability state transition.
+
+    sim_now: the trainer's own trace-time-basis clock (``_sim_now()``) at the
+    moment the transition was applied — sim: virtual-clock seconds; real:
+    wall-elapsed since the shared AGG_START_TS origin (Batch 3 T3.0). Distinct
+    from the record's own wall ``ts`` (always epoch time.time(), meaningless
+    against a trace indexed in trace-seconds). Needed for A6
+    (trainer_trace_fidelity, Batch 3 T3.2) to compare *when* a trainer applied
+    a transition against ground truth, not just *that* it eventually did.
+    Optional/back-compat: None for telemetry recorded before this field existed.
+    """
     return EVENT_AVAIL_CHANGE, {
         "round": round_num,
         "old_state": old_state,
         "new_state": new_state,
+        "sim_now": sim_now,
     }
 
 
@@ -258,6 +280,8 @@ def build_task_send(
     wall_recv_ts: Optional[float],
     wall_send_ts: float,
     time_mode: str,
+    send_gate_wait_s: Optional[float] = None,
+    send_gate_sct: Optional[float] = None,
 ) -> tuple[str, dict[str, Any]]:
     """Trainer finished a task and sent the update back to the aggregator.
 
@@ -266,6 +290,16 @@ def build_task_send(
     ``[wall_recv_ts, wall_send_ts]`` brackets the trainer's true busy/in-flight
     window in real mode.  That interval is the sound basis for real concurrency
     in validate_real: trainer_round's own ts cannot bracket it.
+
+    send_gate_wait_s / send_gate_sct (Batch 3 T3.4, real mode only): the
+    [SEND_GATE] wait loop also runs strictly after trainer_round is emitted
+    (train() -> put()/_send_weights, per the tasklet composition), so — like
+    wall_send_ts above — task_send, not trainer_round, is the event that can
+    actually carry it. send_gate_sct is the trainer's own _sim_now() sampled
+    right before the gate check (same trace-time-basis clock T3.2's
+    avail_change.sim_now uses); send_gate_wait_s is the wall-time actually
+    spent blocked in the loop (0.0 when the gate never engaged). Always None
+    in sim mode (the gate is a real-mode-only mechanism).
     """
     return EVENT_TASK_SEND, {
         "round": round_num,
@@ -274,6 +308,8 @@ def build_task_send(
         "wall_recv_ts": wall_recv_ts,
         "wall_send_ts": wall_send_ts,
         "time_mode": time_mode,
+        "send_gate_wait_s": send_gate_wait_s,
+        "send_gate_sct": send_gate_sct,
     }
 
 
@@ -404,3 +440,112 @@ def build_utility_belief(
     if extra:
         fields.update(extra)
     return EVENT_UTILITY_BELIEF, fields
+
+
+def build_withheld_delivery(
+    *,
+    round_num: int,
+    end_id: str,
+    sct: float,
+    delivery_ts: float,
+    staleness: Optional[int] = None,
+    accepted: Optional[bool] = None,
+    time_mode: str = "sim",
+    actual_commit_ts: Optional[float] = None,
+) -> tuple[str, dict[str, Any]]:
+    """A send-gated update committing late (stale) at its ``delivery_ts``.
+
+    ``delivery_ts − sct`` is the down-window delay the completed update waited
+    while its trainer was ``UN_AVL`` (the compute-completes / gate-the-send /
+    deliver-late model). ``staleness`` = the current round minus the update's
+    ``MODEL_VERSION``; ``accepted`` records the staleness-gate outcome (async
+    fedbuff always accepts; sync feddance may reject over tolerance — Stage E).
+    Backs the ``withheld_delivery`` parity rung.
+
+    actual_commit_ts (Batch 3 T3.5, K11): the aggregator's own clock
+    (``_avail_now()`` — vclock in sim, wall-elapsed in real) sampled at the
+    instant this update actually commits, i.e. AFTER the caller's
+    ``_advance_sim_clock``/equivalent for this specific update, not before —
+    the whole point is to catch reinjection-polling lag between ``delivery_ts``
+    (the earliest legal commit time — already exactly what ``delivery_ts`` is,
+    no separate ``earliest_legally_committable_time`` bookkeeping needed for
+    this single-gate-type v1) and when the update actually lands.
+    ``commit_slack_s = actual_commit_ts - delivery_ts`` is derived by the
+    caller-facing K11 check, not stored here, to keep this builder a thin
+    field-carrier like its siblings.
+    """
+    fields: dict[str, Any] = {
+        "round": round_num,
+        "end_id": end_id,
+        "sct": sct,
+        "delivery_ts": delivery_ts,
+        "delay_s": float(delivery_ts) - float(sct),
+        "time_mode": time_mode,
+    }
+    if staleness is not None:
+        fields["staleness"] = staleness
+    if accepted is not None:
+        fields["accepted"] = accepted
+    if actual_commit_ts is not None:
+        fields["actual_commit_ts"] = float(actual_commit_ts)
+    return EVENT_WITHHELD_DELIVERY, fields
+
+
+def build_abandon_timeout(
+    *,
+    round_num: int,
+    end_id: str,
+    sim_send_ts: float,
+    vclock_now: float,
+    time_mode: str = "sim",
+    reason: str = "abandon_90s_vclock",
+) -> tuple[str, dict[str, Any]]:
+    """A stalled in-flight trainer freed by a slot-free trigger.
+
+    ``reason`` distinguishes C.3 90s-vclock abandons from D.1 aware boundary
+    evictions. ``vclock_now − sim_send_ts`` is the in-flight age at trigger.
+    Backs the ``abandon_timeout`` parity rung, which fails loudly if the
+    deadline is measured on the wall instead of the vclock.
+    """
+    return EVENT_ABANDON_TIMEOUT, {
+        "round": round_num,
+        "end_id": end_id,
+        "sim_send_ts": sim_send_ts,
+        "vclock_now": vclock_now,
+        "age_s": float(vclock_now) - float(sim_send_ts),
+        "time_mode": time_mode,
+        "reason": reason,
+    }
+
+
+def build_agg_belief_change(
+    *,
+    round_num: int,
+    end_id: str,
+    state: str,
+    observed_at: float,
+    checkpoint: str,
+    source: str = "trace_read",
+) -> tuple[str, dict[str, Any]]:
+    """The aggregator's belief about `end_id`'s availability state (Batch 3 T3.3).
+
+    ``checkpoint`` distinguishes WHERE the aggregator's view was read:
+    ``"selection"`` (pre-round eligibility read) or ``"commit"`` (state at an
+    update's completion time, whether or not the mechanism actually gates on
+    it — real mode never gates here, sim's send-gate does; recording both
+    lets A7 compare the aggregator's belief against ground truth regardless).
+    ``source`` is the knowledge MECHANISM the belief came from — ``trace_read``
+    (v1, live) today, ``client_notify``/``predictive`` later (Stage H) — kept
+    mechanism-agnostic so a future populator just passes a different source
+    without any telemetry/checker/plot change. ``observed_at`` is the
+    trace-time-basis clock (vclock seconds / wall-elapsed since the shared
+    origin) at which the belief was read, NOT the record's own wall ``ts``.
+    """
+    return EVENT_AGG_BELIEF_CHANGE, {
+        "round": round_num,
+        "end_id": end_id,
+        "state": state,
+        "observed_at": observed_at,
+        "checkpoint": checkpoint,
+        "source": source,
+    }
diff --git a/lib/python/tests/availability/test_agg_belief.py b/lib/python/tests/availability/test_agg_belief.py
new file mode 100644
index 000000000..18a6ed9e0
--- /dev/null
+++ b/lib/python/tests/availability/test_agg_belief.py
@@ -0,0 +1,188 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.3 — aggregator belief-tracking hooks on ClientAvailability.
+
+_record_avail_belief / _record_commit_belief are mechanism-agnostic telemetry
+hooks (agg_belief_change), not behavior — these tests assert the emission
+schema and the commit-checkpoint gate-off/no-trace no-ops, plus that
+_sim_withhold_if_unavail (the sim commit checkpoint) calls through to it.
+"""
+
+import json
+
+import pytest
+from sortedcontainers import SortedDict
+
+from flame import telemetry
+from flame.availability.client_availability import ClientAvailability
+from flame.telemetry.events import EVENT_AGG_BELIEF_CHANGE, build_agg_belief_change
+
+
+@pytest.fixture(autouse=True)
+def _reset_telemetry():
+    telemetry.shutdown()
+    yield
+    telemetry.shutdown()
+
+
+def _trace(*pairs):
+    d = SortedDict()
+    for ts, state in pairs:
+        d[float(ts)] = state
+    return d
+
+
+class _Harness(ClientAvailability):
+    def __init__(self, trainer_event_dict=None, now=0.0, simulated=True):
+        self.trainer_event_dict = trainer_event_dict
+        self.pending_withheld = {}
+        self._sim_withheld_payload = {}
+        self._sim_withheld_delivering = {}
+        self._now = now
+        self.simulated = simulated
+        self._round = 3
+
+    def _avail_now(self):
+        return self._now
+
+
+# ---------------------------------------------------------------------------
+# build_agg_belief_change schema
+# ---------------------------------------------------------------------------
+
+def test_build_agg_belief_change_schema():
+    ev, f = build_agg_belief_change(
+        round_num=5, end_id="t1", state="UN_AVL", observed_at=120.0,
+        checkpoint="commit", source="trace_read",
+    )
+    assert ev == EVENT_AGG_BELIEF_CHANGE
+    for key in ("round", "end_id", "state", "observed_at", "checkpoint", "source"):
+        assert key in f
+    assert f["checkpoint"] == "commit"
+    assert f["source"] == "trace_read"
+
+
+# ---------------------------------------------------------------------------
+# _record_avail_belief
+# ---------------------------------------------------------------------------
+
+def test_record_avail_belief_noop_when_telemetry_disabled():
+    h = _Harness()
+    h._record_avail_belief("t1", "AVL_TRAIN", observed_at=0.0, checkpoint="selection")
+    # No exception, no writer configured -- nothing to assert beyond "didn't crash".
+
+
+def test_record_avail_belief_emits_when_enabled(tmp_path):
+    telemetry.configure(role="aggregator", run_dir=str(tmp_path))
+    h = _Harness()
+    h._record_avail_belief("t1", "UN_AVL", observed_at=42.0, checkpoint="commit",
+                          source="trace_read")
+    telemetry.shutdown()
+    path = tmp_path / "aggregator.jsonl"
+    lines = [json.loads(l) for l in path.read_text().splitlines() if l.strip()]
+    belief = [l for l in lines if l["event"] == EVENT_AGG_BELIEF_CHANGE]
+    assert len(belief) == 1
+    assert belief[0]["end_id"] == "t1"
+    assert belief[0]["state"] == "UN_AVL"
+    assert belief[0]["observed_at"] == 42.0
+    assert belief[0]["checkpoint"] == "commit"
+    assert belief[0]["round"] == 3
+
+
+# ---------------------------------------------------------------------------
+# _record_commit_belief
+# ---------------------------------------------------------------------------
+
+def test_record_commit_belief_noop_gate_off(tmp_path):
+    telemetry.configure(role="aggregator", run_dir=str(tmp_path))
+    h = _Harness(trainer_event_dict=None)
+    h._record_commit_belief("t1", sct=100.0)
+    telemetry.shutdown()
+    lines = (tmp_path / "aggregator.jsonl").read_text().splitlines()
+    assert not any(json.loads(l)["event"] == EVENT_AGG_BELIEF_CHANGE for l in lines if l.strip())
+
+
+def test_record_commit_belief_noop_missing_trace(tmp_path):
+    telemetry.configure(role="aggregator", run_dir=str(tmp_path))
+    h = _Harness(trainer_event_dict={"t2": _trace((0, "AVL_TRAIN"))})
+    h._record_commit_belief("t1", sct=100.0)  # t1 not in trainer_event_dict
+    telemetry.shutdown()
+    lines = (tmp_path / "aggregator.jsonl").read_text().splitlines()
+    assert not any(json.loads(l)["event"] == EVENT_AGG_BELIEF_CHANGE for l in lines if l.strip())
+
+
+def test_record_commit_belief_reads_state_at_sct(tmp_path):
+    telemetry.configure(role="aggregator", run_dir=str(tmp_path))
+    trace = _trace((0, "AVL_TRAIN"), (600, "UN_AVL"))
+    h = _Harness(trainer_event_dict={"t1": trace})
+    h._record_commit_belief("t1", sct=700.0)  # after the 600s transition
+    telemetry.shutdown()
+    lines = [json.loads(l) for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() if l.strip()]
+    belief = [l for l in lines if l["event"] == EVENT_AGG_BELIEF_CHANGE][0]
+    assert belief["state"] == "UN_AVL"
+    assert belief["observed_at"] == 700.0
+    assert belief["checkpoint"] == "commit"
+
+
+def test_record_commit_belief_defaults_to_avail_now(tmp_path):
+    telemetry.configure(role="aggregator", run_dir=str(tmp_path))
+    trace = _trace((0, "AVL_TRAIN"))
+    h = _Harness(trainer_event_dict={"t1": trace}, now=55.0)
+    h._record_commit_belief("t1")  # sct=None -> _avail_now()
+    telemetry.shutdown()
+    lines = [json.loads(l) for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() if l.strip()]
+    belief = [l for l in lines if l["event"] == EVENT_AGG_BELIEF_CHANGE][0]
+    assert belief["observed_at"] == 55.0
+
+
+# ---------------------------------------------------------------------------
+# _sim_withhold_if_unavail calls through to _record_commit_belief
+# ---------------------------------------------------------------------------
+
+def test_sim_withhold_if_unavail_records_commit_belief(monkeypatch):
+    h = _Harness(trainer_event_dict={"t1": _trace((0, "AVL_TRAIN"))})
+    calls = []
+    monkeypatch.setattr(h, "_record_commit_belief", lambda end, sct=None: calls.append((end, sct)))
+    # Available the whole time -> gate returns False (commits now), but the
+    # belief must still have been recorded before that decision.
+    result = h._sim_withhold_if_unavail(channel=None, end="t1", sct=10.0, msgmd=None)
+    assert result is False
+    assert calls == [("t1", 10.0)]
+
+
+def test_sim_withhold_if_unavail_gate_off_never_records_belief(monkeypatch):
+    h = _Harness(trainer_event_dict=None)
+    calls = []
+    monkeypatch.setattr(h, "_record_commit_belief", lambda end, sct=None: calls.append((end, sct)))
+    result = h._sim_withhold_if_unavail(channel=None, end="t1", sct=10.0, msgmd=None)
+    assert result is False
+    assert calls == []
+
+
+# ---------------------------------------------------------------------------
+# _emit_withheld_delivery (Batch 3 T3.5 — K11 commit_promptness)
+# ---------------------------------------------------------------------------
+
+def test_emit_withheld_delivery_stamps_actual_commit_ts(tmp_path):
+    """actual_commit_ts must reflect the CALLER's clock at emission time
+    (_avail_now(), sampled fresh -- not orig_sct/delivery_ts, which are just
+    passed through). The caller is responsible for advancing its clock for
+    THIS commit before calling (see syncfl/oort top_aggregator.py's Batch 3
+    T3.5 reorder) -- this test only asserts the harness's current _avail_now()
+    ends up on the emitted event, not the reorder itself (that's covered by
+    the existing top_aggregator withheld-commit-loop tests continuing to pass
+    unchanged, since the reorder touches only telemetry timing, not state)."""
+    telemetry.configure(role="aggregator", run_dir=str(tmp_path))
+    h = _Harness(now=305.5)
+    h._emit_withheld_delivery("t1", {}, orig_sct=100.0, delivery_ts=300.0)
+    telemetry.shutdown()
+    lines = [json.loads(l) for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() if l.strip()]
+    ev = [l for l in lines if l["event"] == "withheld_delivery"][0]
+    assert ev["sct"] == 100.0
+    assert ev["delivery_ts"] == 300.0
+    assert ev["actual_commit_ts"] == 305.5
+
+
+def test_emit_withheld_delivery_noop_when_telemetry_disabled():
+    h = _Harness(now=100.0)
+    h._emit_withheld_delivery("t1", {}, orig_sct=0.0, delivery_ts=50.0)  # must not raise
diff --git a/lib/python/tests/availability/test_delivery_ledger.py b/lib/python/tests/availability/test_delivery_ledger.py
new file mode 100644
index 000000000..22742bee2
--- /dev/null
+++ b/lib/python/tests/availability/test_delivery_ledger.py
@@ -0,0 +1,150 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Stage C substrate: delivery ledger + slot-free hook on ClientAvailability.
+
+These exercise the pure delivery-ledger logic (compute_delivery_ts, the
+pending_withheld ordering/residence/commit helpers, and free_stalled_slot's
+two-ledger effect) in isolation from the full sim aggregator. They assert the
+three Stage C correctness invariants at the substrate level:
+  1. no double-count / slot freed exactly once,
+  2. a still-down trainer is excluded until its delivery_ts (never re-selected),
+  3. withheld delivery commits in delivery_ts order (no past-dating).
+And the gate-off no-op that preserves byte-identity.
+"""
+
+from sortedcontainers import SortedDict
+
+from flame.availability.client_availability import ClientAvailability
+
+
+def _trace(*pairs):
+    d = SortedDict()
+    for ts, state in pairs:
+        d[float(ts)] = state
+    return d
+
+
+class _FakeSelector:
+    def __init__(self):
+        self.requester = "agg"
+        self.all_selected = {}
+        self.selected_ends = {"agg": set()}
+
+
+class _FakeEnd:
+    def __init__(self):
+        self.props = {}
+
+    def set_property(self, k, v):
+        self.props[k] = v
+
+
+class _FakeChannel:
+    def __init__(self, ends):
+        self._selector = _FakeSelector()
+        self._ends = {e: _FakeEnd() for e in ends}
+
+    def has(self, end):
+        return end in self._ends
+
+
+class _Harness(ClientAvailability):
+    """Minimal mixin host with a controllable clock and gate state."""
+
+    def __init__(self, trainer_event_dict=None, now=0.0):
+        self.trainer_event_dict = trainer_event_dict
+        self.pending_withheld = {}
+        self._now = now
+
+    def _avail_now(self):  # override the vclock/wall source
+        return self._now
+
+
+# down window: [100, 200); recovers (AVL_TRAIN) at 200.
+_DOWN = _trace((0, "AVL_TRAIN"), (100, "UN_AVL"), (200, "AVL_TRAIN"))
+
+
+def test_compute_delivery_ts_in_down_window():
+    h = _Harness({"t1": _DOWN}, now=130)
+    # update completed at sct=150 while down; delivers when AVL again (200).
+    assert h.compute_delivery_ts("t1", sct=150) == 200.0
+
+
+def test_compute_delivery_ts_clamped_to_sct():
+    # next_avail (200) is earlier than a late sct (260): delivery cannot
+    # precede completion, so delivery_ts = sct.
+    h = _Harness({"t1": _DOWN}, now=130)
+    assert h.compute_delivery_ts("t1", sct=260) == 260.0
+
+
+def test_compute_delivery_ts_never_recovers_is_inf():
+    never = _trace((0, "AVL_TRAIN"), (100, "UN_AVL"))
+    h = _Harness({"t1": never}, now=130)
+    assert h.compute_delivery_ts("t1", sct=150) == float("inf")
+
+
+def test_compute_delivery_ts_gate_off_returns_sct():
+    h = _Harness(trainer_event_dict=None, now=130)
+    assert h.compute_delivery_ts("t1", sct=150) == 150.0
+
+
+def test_free_stalled_slot_frees_slot_and_registers_delivery():
+    h = _Harness({"t1": _DOWN}, now=150)
+    ch = _FakeChannel(["t1"])
+    ch._selector.all_selected["t1"] = 12345.0
+    ch._selector.selected_ends["agg"].add("t1")
+
+    dts = h.free_stalled_slot(ch, "t1", reason="abandon_90s", sct=150)
+
+    assert dts == 200.0
+    # slot ledger: released
+    assert "t1" not in ch._selector.all_selected
+    assert "t1" not in ch._selector.selected_ends["agg"]
+    assert ch._ends["t1"].props["state"] == "none"
+    # delivery ledger: registered
+    assert h.pending_withheld == {"t1": 200.0}
+
+
+def test_free_stalled_slot_gate_off_is_noop():
+    h = _Harness(trainer_event_dict=None, now=150)
+    ch = _FakeChannel(["t1"])
+    ch._selector.all_selected["t1"] = 12345.0
+    assert h.free_stalled_slot(ch, "t1", reason="x", sct=150) is None
+    # nothing freed, nothing registered (byte-identity preserved)
+    assert ch._selector.all_selected == {"t1": 12345.0}
+    assert h.pending_withheld == {}
+
+
+def test_withheld_held_ends_excludes_until_delivery():
+    h = _Harness({"t1": _DOWN}, now=150)
+    h.pending_withheld = {"t1": 200.0, "t2": 180.0}
+    # before either delivery_ts: both held (invariant 2)
+    h._now = 170
+    assert h.withheld_held_ends() == {"t1", "t2"}
+    # past t2's delivery_ts: only t1 still held
+    h._now = 190
+    assert h.withheld_held_ends() == {"t1"}
+    # past both: none held
+    h._now = 250
+    assert h.withheld_held_ends() == set()
+
+
+def test_ready_withheld_orders_by_delivery_ts_then_id():
+    h = _Harness({"t1": _DOWN}, now=300)
+    h.pending_withheld = {"t3": 200.0, "t1": 200.0, "t2": 150.0}
+    # all due at now=300; order by (delivery_ts, end_id): t2,150 < t1,200 < t3,200
+    assert h.ready_withheld() == [("t2", 150.0), ("t1", 200.0), ("t3", 200.0)]
+
+
+def test_ready_withheld_excludes_future():
+    h = _Harness({"t1": _DOWN}, now=190)
+    h.pending_withheld = {"t1": 200.0, "t2": 150.0}
+    assert h.ready_withheld() == [("t2", 150.0)]
+
+
+def test_commit_withheld_pops():
+    h = _Harness({"t1": _DOWN}, now=200)
+    h.pending_withheld = {"t1": 200.0}
+    assert h.commit_withheld("t1") == 200.0
+    assert h.pending_withheld == {}
+    assert h.commit_withheld("t1") is None  # idempotent: no double-count
diff --git a/lib/python/tests/availability/test_live_wiring.py b/lib/python/tests/availability/test_live_wiring.py
new file mode 100644
index 000000000..359cf8db2
--- /dev/null
+++ b/lib/python/tests/availability/test_live_wiring.py
@@ -0,0 +1,545 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Stage C live-wiring: the shared commit-loop primitives in ClientAvailability.
+
+The send-gate withhold / late re-commit / vclock-abandon EFFECT is library-level
+(both the asyncfl _sim_recv_min pop site and the oort _sim_drain_buffer pop loop
+call the same mixin methods). These exercise that shared core directly against a
+real SimReorderBuffer and both selector shapes:
+
+  * asyncfl selectors: selected_ends = dict[requester -> set], plus all_selected
+  * oort/refl/feddance: selected_ends = flat set, no all_selected
+
+They assert the three Stage C invariants at the wiring level:
+  1. no double-count — an abandoned-then-arrived update commits exactly once,
+  2. a still-down trainer is excluded until delivery_ts (held in the ledger),
+  3. withheld delivery re-injects in delivery_ts order (no past-dating).
+Plus the gate-off byte-identity no-op and the Challenge-7 composition contract
+(why oort must gate carry-over BEFORE the send-gate).
+"""
+
+import math
+
+from sortedcontainers import SortedDict
+
+from flame.availability.client_availability import ClientAvailability
+from flame.config import TrainerAvailState
+from flame.selector.properties import PROP_AVL_STATE, PROP_SIM_SEND_TS
+from flame.sim import SimReorderBuffer
+
+
+def _trace(*pairs):
+    d = SortedDict()
+    for ts, state in pairs:
+        d[float(ts)] = state
+    return d
+
+
+# down window [100,200); recovers (AVL_TRAIN) at 200.
+_DOWN = _trace((0, "AVL_TRAIN"), (100, "UN_AVL"), (200, "AVL_TRAIN"))
+# late down window [300,400); used for future-sct composition.
+_LATE_DOWN = _trace((0, "AVL_TRAIN"), (300, "UN_AVL"), (400, "AVL_TRAIN"))
+# never recovers after going down.
+_NEVER = _trace((0, "AVL_TRAIN"), (100, "UN_AVL"))
+
+
+class _FakeEnd:
+    def __init__(self):
+        self.props = {}
+
+    def set_property(self, k, v):
+        self.props[k] = v
+
+    def get_property(self, k):
+        return self.props.get(k)
+
+
+class _AsyncSelector:
+    """fedbuff/async_oort shape: dict-by-requester + all_selected."""
+
+    def __init__(self):
+        self.requester = "agg"
+        self.all_selected = {}
+        self.selected_ends = {"agg": set()}
+
+    def add(self, end):
+        self.all_selected[end] = 0.0
+        self.selected_ends["agg"].add(end)
+
+    def holds(self, end):
+        return end in self.selected_ends["agg"]
+
+
+class _OortSelector:
+    """oort/refl/feddance shape: flat set, no all_selected."""
+
+    def __init__(self):
+        self.selected_ends = set()
+
+    def add(self, end):
+        self.selected_ends.add(end)
+
+    def holds(self, end):
+        return end in self.selected_ends
+
+
+class _Channel:
+    def __init__(self, selector, ends):
+        self._selector = selector
+        self._ends = {e: _FakeEnd() for e in ends}
+        self._props = {}
+
+    def has(self, end):
+        return end in self._ends
+
+    def get_end_property(self, end, key):
+        return self._props.get((end, key))
+
+    def set_end_property(self, end, key, value):
+        self._props[(end, key)] = value
+
+
+class _Harness(ClientAvailability):
+    """Minimal mixin host with a controllable clock + a real reorder buffer."""
+
+    def __init__(self, trainer_event_dict=None, now=0.0, inflight_tracker=False):
+        self.trainer_event_dict = trainer_event_dict
+        # Mirrors _init_availability's derivation (production sets this once at
+        # load time, not per-call) — kept in sync here so harness tests exercise
+        # the same guard real runs do.
+        self._trace_has_avl_eval = bool(trainer_event_dict) and any(
+            TrainerAvailState.AVL_EVAL in trace.values()
+            for trace in trainer_event_dict.values()
+        )
+        self.pending_withheld = {}
+        self._sim_withheld_payload = {}
+        self._sim_withheld_delivering = {}
+        self._sim_buffer = SimReorderBuffer()
+        self._sim_committed = set()
+        self._round = 5
+        self._now = now
+        # asyncfl tracks an in-flight gate dict; oort does not.
+        if inflight_tracker:
+            self._sim_inflight_expected = {}
+
+    def _avail_now(self):
+        return self._now
+
+
+def _payload(tag):
+    # opaque to the helpers (only telemetry reads MODEL_VERSION, off in tests).
+    return ({"tag": tag}, (tag, None))
+
+
+# ---------------------------------------------------------------------------
+# _sim_withhold_if_unavail — the shared per-update send-gate primitive
+# ---------------------------------------------------------------------------
+
+def test_withhold_if_unavail_holds_unavailable_at_sct():
+    h = _Harness({"t1": _DOWN}, now=130, inflight_tracker=True)
+    sel = _AsyncSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    h._sim_inflight_expected["t1"] = 999.0
+    p = _payload("t1")
+
+    # completed at sct=150 while UN_AVL -> held, slot freed, ledger registered.
+    assert h._sim_withhold_if_unavail(ch, "t1", 150.0, p) is True
+    assert h.pending_withheld == {"t1": 200.0}
+    assert h._sim_withheld_payload["t1"] == (150.0, p)
+    assert not sel.holds("t1")                      # slot freed
+    assert "t1" not in h._sim_inflight_expected     # gate tracker cleared
+
+
+def test_withhold_if_unavail_commits_when_available():
+    h = _Harness({"t1": _DOWN}, now=260)
+    sel = _AsyncSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    # sct=260 is past the down window -> available -> committable, no withhold.
+    assert h._sim_withhold_if_unavail(ch, "t1", 260.0, _payload("t1")) is False
+    assert h.pending_withheld == {}
+
+
+def test_withhold_if_unavail_gate_off_is_noop():
+    h = _Harness(trainer_event_dict=None, now=150)
+    sel = _AsyncSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    assert h._sim_withhold_if_unavail(ch, "t1", 150.0, _payload("t1")) is False
+    assert sel.holds("t1")          # nothing freed
+    assert h.pending_withheld == {}
+
+
+def test_withhold_if_unavail_never_recovers_drops_payload():
+    h = _Harness({"t1": _NEVER}, now=130)
+    sel = _OortSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    # undeliverable in-window: slot still freed + ledger registered (inf), but no
+    # payload stashed (Challenge 10 edge).
+    assert h._sim_withhold_if_unavail(ch, "t1", 150.0, _payload("t1")) is True
+    assert h.pending_withheld == {"t1": math.inf}
+    assert "t1" not in h._sim_withheld_payload
+    assert not sel.holds("t1")
+
+
+def test_withhold_does_not_consult_round_start():
+    # Contract that makes oort's carry-over-first ordering load-bearing
+    # (Challenge 7): the send-gate is a PURE per-update decision keyed on the
+    # trainer's state at sct — it would withhold a still-computing future-sct
+    # UN_AVL straggler if called directly. So the oort loop MUST apply carry-over
+    # (still-computing) before this, or it would free a slot that is still busy.
+    h = _Harness({"t1": _LATE_DOWN}, now=50)
+    sel = _OortSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    # sct=350 is in the future (still computing) AND UN_AVL at 350.
+    assert h._sim_withhold_if_unavail(ch, "t1", 350.0, _payload("t1")) is True
+
+
+# ---------------------------------------------------------------------------
+# _sim_pop_committable — asyncfl loop
+# ---------------------------------------------------------------------------
+
+def test_pop_committable_skips_withheld_returns_next():
+    h = _Harness({"t1": _DOWN, "t2": _DOWN}, now=130, inflight_tracker=True)
+    sel = _AsyncSelector(); sel.add("t1"); sel.add("t2")
+    ch = _Channel(sel, ["t1", "t2"])
+    # t1 completes UN_AVL at 150 (held); t2 completes available at 260 (commit).
+    h._sim_buffer.add("t1", 150.0, _payload("t1"))
+    h._sim_buffer.add("t2", 260.0, _payload("t2"))
+
+    popped = h._sim_pop_committable(ch)
+    assert popped is not None and popped[0] == "t2"
+    assert "t1" in h.pending_withheld and not sel.holds("t1")
+    # t2 is the only committable; buffer now empty.
+    assert h._sim_pop_committable(ch) is None
+
+
+def test_pop_committable_gate_off_single_pop():
+    h = _Harness(trainer_event_dict=None, now=0)
+    sel = _AsyncSelector(); sel.add("a")
+    ch = _Channel(sel, ["a"])
+    h._sim_buffer.add("a", 10.0, _payload("a"))
+    popped = h._sim_pop_committable(ch)
+    assert popped[0] == "a" and popped[1] == 10.0
+    assert h.pending_withheld == {}
+
+
+# ---------------------------------------------------------------------------
+# _sim_reinject_ready_withheld — ordering, residence, slot-only drop
+# ---------------------------------------------------------------------------
+
+def test_reinject_adds_due_in_order_marks_delivering():
+    h = _Harness({"t1": _DOWN}, now=200)
+    h.pending_withheld = {"t1": 200.0, "t2": 150.0}
+    p1, p2 = _payload("t1"), _payload("t2")
+    h._sim_withheld_payload = {"t1": (150.0, p1), "t2": (120.0, p2)}
+
+    h._sim_reinject_ready_withheld()
+    # both due at now=200 -> both re-injected, ledger emptied, marked delivering.
+    assert h.pending_withheld == {}
+    assert h._sim_buffer.has("t1") and h._sim_buffer.has("t2")
+    assert h._sim_withheld_delivering["t1"] == (150.0, 200.0)
+    assert h._sim_withheld_delivering["t2"] == (120.0, 150.0)
+    # re-injected keyed at delivery_ts (commit order), so t2(150) pops before t1(200).
+    assert h._sim_buffer.pop_min()[0] == "t2"
+
+
+def test_reinject_excludes_future():
+    h = _Harness({"t1": _DOWN}, now=190)
+    h.pending_withheld = {"t1": 200.0}
+    h._sim_withheld_payload = {"t1": (150.0, _payload("t1"))}
+    h._sim_reinject_ready_withheld()
+    # not yet due (200 > 190): still held, not in buffer.
+    assert h.pending_withheld == {"t1": 200.0}
+    assert not h._sim_buffer.has("t1")
+
+
+def test_reinject_keeps_slot_only_entry_until_payload_arrives():
+    # Eviction registered an ESTIMATED delivery_ts before the trainer's update
+    # had physically completed. A reinject tick that lands after the estimate
+    # but before the payload shows up must NOT drop the ledger entry (Next
+    # actions §2 under-emission bug) — it stays registered, still excluded via
+    # withheld_held_ends() at the original dts is moot once now > dts, but the
+    # ledger entry itself must survive for the payload to be recognized later.
+    h = _Harness({"t1": _DOWN}, now=250)
+    h.pending_withheld = {"t1": 200.0}  # no payload yet
+    h._sim_reinject_ready_withheld()
+    assert h.pending_withheld == {"t1": 200.0}       # NOT dropped
+    assert not h._sim_buffer.has("t1")                # nothing to deliver yet
+    assert "t1" not in h._sim_withheld_delivering
+
+    # the physical update now arrives (actual sct=250, past the original
+    # estimate) via the normal pop path -> recognized as still-withheld,
+    # delivery_ts bumped to the real completion time (no past-dating).
+    sel = _OortSelector()
+    ch = _Channel(sel, ["t1"])
+    p = _payload("t1")
+    h._sim_buffer.add("t1", 250.0, p)
+    assert h._sim_pop_committable(ch) is None         # held, not committed
+    assert h.pending_withheld == {"t1": 250.0}        # bumped from the estimate
+    assert h._sim_withheld_payload["t1"] == (250.0, p)
+
+    h._sim_reinject_ready_withheld()
+    assert h.pending_withheld == {}
+    assert h._sim_buffer.has("t1")
+    assert h._sim_withheld_delivering["t1"] == (250.0, 250.0)
+
+
+# ---------------------------------------------------------------------------
+# Invariant 1 — abandoned-then-arrived commits exactly once
+# ---------------------------------------------------------------------------
+
+def test_invariant1_abandoned_then_arrived_commits_once():
+    h = _Harness({"t1": _DOWN}, now=150, inflight_tracker=True)
+    sel = _AsyncSelector()
+    ch = _Channel(sel, ["t1"])
+    # abandon already registered the ledger (slot-only, no payload yet).
+    h.pending_withheld = {"t1": 200.0}
+    h._sim_inflight_expected["t1"] = 999.0
+
+    # the physical update now arrives in the buffer.
+    h._sim_buffer.add("t1", 155.0, _payload("t1"))
+    # pop: end is in pending_withheld -> stash payload, do NOT re-register/commit.
+    assert h._sim_pop_committable(ch) is None
+    assert h.pending_withheld == {"t1": 200.0}          # unchanged (no double-reg)
+    assert h._sim_withheld_payload["t1"][0] == 155.0    # arrived payload stashed
+    assert "t1" not in h._sim_inflight_expected
+
+    # at delivery_ts, reinject delivers it; pop commits exactly once.
+    h._now = 200
+    h._sim_reinject_ready_withheld()
+    popped = h._sim_pop_committable(ch)
+    assert popped is not None and popped[0] == "t1"
+    assert h.pending_withheld == {}                      # fully drained
+    assert h._sim_pop_committable(ch) is None            # no second commit
+
+
+# ---------------------------------------------------------------------------
+# C.3 — vclock abandon (both selector shapes)
+# ---------------------------------------------------------------------------
+
+def _setup_abandon(selector_cls, inflight_tracker):
+    h = _Harness({"t1": _DOWN}, now=300, inflight_tracker=inflight_tracker)
+    sel = selector_cls(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    if inflight_tracker:
+        h._sim_inflight_expected["t1"] = 12.0
+    return h, sel, ch
+
+
+def test_abandon_fires_past_90s_async_shape():
+    h, sel, ch = _setup_abandon(_AsyncSelector, inflight_tracker=True)
+    ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 100)  # age 100 > 90
+    h._sim_abandon_stalled(ch)
+    assert not sel.holds("t1")                  # slot freed -> replacement selectable
+    assert "t1" in h.pending_withheld           # delivery ledger registered
+    assert "t1" not in h._sim_inflight_expected
+
+
+def test_abandon_fires_past_90s_oort_shape():
+    h, sel, ch = _setup_abandon(_OortSelector, inflight_tracker=False)
+    ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 95)   # age 95 > 90
+    h._sim_abandon_stalled(ch)
+    assert not sel.holds("t1")
+    assert "t1" in h.pending_withheld
+
+
+def test_abandon_does_not_fire_under_90s():
+    h, sel, ch = _setup_abandon(_OortSelector, inflight_tracker=False)
+    ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 50)   # age 50 <= 90
+    h._sim_abandon_stalled(ch)
+    assert sel.holds("t1")                      # still in-flight
+    assert h.pending_withheld == {}
+
+
+def test_abandon_skips_buffered_committed_and_withheld():
+    h, sel, ch = _setup_abandon(_OortSelector, inflight_tracker=False)
+    ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 100)
+    # already arrived in the buffer -> not stalled.
+    h._sim_buffer.add("t1", 250.0, _payload("t1"))
+    h._sim_abandon_stalled(ch)
+    assert sel.holds("t1") and h.pending_withheld == {}
+
+
+def test_abandon_gate_off_is_noop():
+    h = _Harness(trainer_event_dict=None, now=300)
+    sel = _OortSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    ch.set_end_property("t1", PROP_SIM_SEND_TS, 0.0)
+    h._sim_abandon_stalled(ch)
+    assert sel.holds("t1") and h.pending_withheld == {}
+
+
+# ---------------------------------------------------------------------------
+# _sim_evict_unavail_inflight — Stage D.1 proactive boundary eviction
+# ---------------------------------------------------------------------------
+# Uses _DOWN: AVL_TRAIN[0,100) → UN_AVL[100,200) → AVL_TRAIN[200,∞)
+
+
+def _harness_aware(now, ends=("t1",), selector_cls=_OortSelector):
+    """Harness with proactive_inflight_evict=True, vclock at `now`."""
+    h = _Harness({"t1": _DOWN, "t2": _DOWN}, now=now)
+    h.proactive_inflight_evict = True
+    sel = selector_cls()
+    for e in ends:
+        sel.add(e)
+    ch = _Channel(sel, list(ends))
+    return h, sel, ch
+
+
+def test_evict_frees_slot_for_unavail_trainer_oort():
+    # vclock=150 → t1 is UN_AVL [100,200); should be evicted immediately.
+    h, sel, ch = _harness_aware(150, ("t1",), _OortSelector)
+    h._sim_evict_unavail_inflight(ch)
+    assert not sel.holds("t1")
+    assert "t1" in h.pending_withheld
+    assert h.pending_withheld["t1"] == 200.0  # next AVL_TRAIN from trace
+
+
+def test_evict_frees_slot_for_unavail_trainer_async():
+    h, sel, ch = _harness_aware(150, ("t1",), _AsyncSelector)
+    h._sim_evict_unavail_inflight(ch)
+    assert not sel.holds("t1")
+    assert h.pending_withheld["t1"] == 200.0
+
+
+def test_evict_leaves_available_trainer():
+    # vclock=50 → t1 is AVL_TRAIN; no eviction.
+    h, sel, ch = _harness_aware(50, ("t1",), _OortSelector)
+    h._sim_evict_unavail_inflight(ch)
+    assert sel.holds("t1")
+    assert h.pending_withheld == {}
+
+
+def test_evict_skips_buffered_trainer():
+    # t1 is UN_AVL at vclock=150 but its update already arrived in the buffer
+    # → not stalled → eviction skipped.
+    h, sel, ch = _harness_aware(150, ("t1",), _OortSelector)
+    h._sim_buffer.add("t1", 120.0, _payload("t1"))
+    h._sim_evict_unavail_inflight(ch)
+    assert sel.holds("t1")
+    assert h.pending_withheld == {}
+
+
+def test_evict_skips_already_withheld():
+    # Invariant 1: t1 already in pending_withheld → no double-count.
+    h, sel, ch = _harness_aware(150, ("t1",), _OortSelector)
+    h.pending_withheld["t1"] = 200.0
+    h._sim_evict_unavail_inflight(ch)
+    assert sel.holds("t1")             # nothing changed
+    assert h.pending_withheld == {"t1": 200.0}
+
+
+def test_evict_noop_when_awareness_false():
+    # proactive_inflight_evict=False → falls through to 90s abandon; evict is inert.
+    h, sel, ch = _harness_aware(150, ("t1",), _OortSelector)
+    h.proactive_inflight_evict = False
+    h._sim_evict_unavail_inflight(ch)
+    assert sel.holds("t1")
+    assert h.pending_withheld == {}
+
+
+def test_evict_noop_when_gate_off():
+    h = _Harness(trainer_event_dict=None, now=150)
+    h.proactive_inflight_evict = True
+    sel = _OortSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1"])
+    h._sim_evict_unavail_inflight(ch)
+    assert sel.holds("t1")
+    assert h.pending_withheld == {}
+
+
+def test_evict_multiple_trainers_partial():
+    # t1 in UN_AVL[100,200), t2 has a different trace where it's AVL at vclock=150.
+    # Only t1 should be evicted.
+    _avl_trace = _trace((0, "AVL_TRAIN"))
+    h = _Harness({"t1": _DOWN, "t2": _avl_trace}, now=150)
+    h.proactive_inflight_evict = True
+    sel = _OortSelector(); sel.add("t1"); sel.add("t2")
+    ch = _Channel(sel, ["t1", "t2"])
+    h._sim_evict_unavail_inflight(ch)
+    assert not sel.holds("t1")
+    assert sel.holds("t2")
+    assert "t1" in h.pending_withheld
+    assert "t2" not in h.pending_withheld
+
+
+# ---------------------------------------------------------------------------
+# _avail_stamp_end_states — avail_composition/avl_state blind-spot fix
+# ---------------------------------------------------------------------------
+
+def test_stamp_end_states_writes_every_known_end():
+    # t1 in-flight UN_AVL[100,200) (e.g. just D.1-evicted); t2 plain AVL_TRAIN.
+    # Both are stamped, including the in-flight/evicted one — the whole point
+    # is this no longer depends on being in a "fresh candidate" subset.
+    h = _Harness({"t1": _DOWN, "t2": _trace((0, "AVL_TRAIN"))}, now=150)
+    sel = _OortSelector(); sel.add("t1")
+    ch = _Channel(sel, ["t1", "t2"])
+    h._avail_stamp_end_states(ch)
+    assert ch.get_end_property("t1", PROP_AVL_STATE) == TrainerAvailState.UN_AVL
+    assert ch.get_end_property("t2", PROP_AVL_STATE) == TrainerAvailState.AVL_TRAIN
+
+
+def test_stamp_end_states_defaults_avl_train_when_no_trace():
+    h = _Harness({"t1": _DOWN}, now=150)
+    sel = _OortSelector()
+    ch = _Channel(sel, ["t1", "t2"])  # t2 has no per-trainer trace entry
+    h._avail_stamp_end_states(ch)
+    assert ch.get_end_property("t2", PROP_AVL_STATE) == TrainerAvailState.AVL_TRAIN
+
+
+def test_stamp_end_states_noop_when_gate_off():
+    h = _Harness(trainer_event_dict=None, now=150)
+    sel = _OortSelector()
+    ch = _Channel(sel, ["t1"])
+    h._avail_stamp_end_states(ch)
+    assert ch.get_end_property("t1", PROP_AVL_STATE) is None
+
+
+# ---------------------------------------------------------------------------
+# get_curr_task_ineligible_trainers — D.2 task-type (AVL_TRAIN/AVL_EVAL) gate
+# ---------------------------------------------------------------------------
+
+_TRAIN_THEN_EVAL = _trace((0, "AVL_TRAIN"), (100, "AVL_EVAL"))
+
+
+def test_task_ineligible_excludes_un_avl_for_both_tasks():
+    h = _Harness({"t1": _DOWN}, now=150)  # UN_AVL[100,200)
+    assert h.get_curr_task_ineligible_trainers("train") == ["t1"]
+    assert h.get_curr_task_ineligible_trainers("eval") == ["t1"]
+
+
+def test_task_ineligible_excludes_avl_eval_from_train_dispatch():
+    h = _Harness({"t1": _TRAIN_THEN_EVAL}, now=150)  # AVL_EVAL at t=150
+    assert h.get_curr_task_ineligible_trainers("train") == ["t1"]
+    assert h.get_curr_task_ineligible_trainers("eval") == []
+
+
+def test_task_ineligible_excludes_avl_train_from_eval_dispatch():
+    h = _Harness({"t1": _TRAIN_THEN_EVAL}, now=50)  # AVL_TRAIN at t=50
+    assert h.get_curr_task_ineligible_trainers("eval") == ["t1"]
+    assert h.get_curr_task_ineligible_trainers("train") == []
+
+
+def test_task_ineligible_unknown_task_matches_unavail_only():
+    h = _Harness({"t1": _TRAIN_THEN_EVAL}, now=150)  # AVL_EVAL
+    assert h.get_curr_task_ineligible_trainers("htbt") == []
+
+
+def test_task_ineligible_gate_off_is_noop():
+    h = _Harness(trainer_event_dict=None, now=150)
+    assert h.get_curr_task_ineligible_trainers("train") == []
+    assert h.get_curr_task_ineligible_trainers("eval") == []
+
+
+def test_task_ineligible_2state_trace_does_not_exclude_avl_train_from_eval():
+    # Regression (found via a real felix syn_0 hang, Jun 28): syn_0/syn_20 are
+    # 2-state (AVL_TRAIN/UN_AVL only, no AVL_EVAL ever). Excluding AVL_TRAIN
+    # from eval on such a trace makes eval's eligible pool PERMANENTLY EMPTY,
+    # which corrupts the selector's shared in-flight tracking for train too
+    # (async_oort.py/fedbuff.py _handle_send_state's "invalid prior selection"
+    # cleanup wipes selected_ends when ends={}) — the aggregator stops reading
+    # completed train responses entirely. _trace_has_avl_eval must gate this off
+    # for a trace that never produces AVL_EVAL for ANY trainer.
+    h = _Harness({"t1": _DOWN, "t2": _trace((0, "AVL_TRAIN"))}, now=50)  # all AVL_TRAIN
+    assert h._trace_has_avl_eval is False
+    assert h.get_curr_task_ineligible_trainers("eval") == []
+    assert h.get_curr_task_ineligible_trainers("train") == []
diff --git a/lib/python/tests/availability/test_starvation_termination.py b/lib/python/tests/availability/test_starvation_termination.py
new file mode 100644
index 000000000..a1622dfb4
--- /dev/null
+++ b/lib/python/tests/availability/test_starvation_termination.py
@@ -0,0 +1,201 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Regression tests for B2.0.2 — starvation self-termination.
+
+Bug: when the trace horizon is reached, _next_avail_vclock() returns None
+(or a value <= vclock.now), the starvation branch returned without advancing
+and without setting _work_done, causing infinite spins until the wall ceiling.
+The budget check in increment_round used strict > so vclock exactly at budget
+never stopped either.
+
+These tests verify that both conditions now terminate correctly.
+"""
+
+import math
+import types
+
+import pytest
+from sortedcontainers import SortedDict
+
+from flame.availability.client_availability import ClientAvailability
+from flame.availability.trace import next_avail_after
+
+
+# ---------------------------------------------------------------------------
+# Minimal clock + trace helpers
+# ---------------------------------------------------------------------------
+
+def _trace(*pairs):
+    d = SortedDict()
+    for ts, state in pairs:
+        d[float(ts)] = state
+    return d
+
+
+# A trace where all trainers go UN_AVL at t=500 and never recover.
+_EXHAUST = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"))
+
+# A trace where trainer recovers much later — used to verify _next_avail_vclock
+# returns a finite future value when not exhausted.
+_RECOVER = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (800, "AVL_TRAIN"))
+
+
+class _VClock:
+    def __init__(self, now):
+        self._now = float(now)
+
+    @property
+    def now(self):
+        return self._now
+
+    def advance(self, ts):
+        if float(ts) > self._now:
+            self._now = float(ts)
+
+
+class _Harness(ClientAvailability):
+    """Minimal ClientAvailability host for starvation-termination tests."""
+
+    def __init__(self, trainer_event_dict, vclock_now, budget, simulated=True):
+        self.trainer_event_dict = trainer_event_dict
+        self._trace_has_avl_eval = False
+        self.pending_withheld = {}
+        self._sim_withheld_payload = {}
+        self._sim_withheld_delivering = {}
+        self._vclock = _VClock(vclock_now)
+        self._work_done = False
+        self._round = 1
+        self.simulated = simulated
+        self.avail_select_filter = True
+        self.proactive_inflight_evict = False
+        self.agg_start_time_ts = 0.0  # for real-mode wall-elapsed check
+        # Minimal config mock
+        hp = types.SimpleNamespace(
+            max_experiment_runtime_s=budget,
+            aggregation_goal=5,
+        )
+        self.config = types.SimpleNamespace(hyperparameters=hp)
+
+    def _avail_now(self):
+        return self._vclock.now
+
+
+# ---------------------------------------------------------------------------
+# _next_avail_vclock behaviour
+# ---------------------------------------------------------------------------
+
+def test_next_avail_vclock_returns_none_when_trace_exhausted():
+    """All trainers permanently UN_AVL → no future recovery → None."""
+    h = _Harness({"t1": _EXHAUST, "t2": _EXHAUST}, vclock_now=600, budget=1800)
+    result = h._next_avail_vclock()
+    assert result is None, f"Expected None, got {result}"
+
+
+def test_next_avail_vclock_returns_future_when_recovery_exists():
+    """Trainer recovers at t=800; query at t=600 → 800.0 returned."""
+    h = _Harness({"t1": _EXHAUST, "t2": _RECOVER}, vclock_now=600, budget=1800)
+    result = h._next_avail_vclock()
+    assert result == 800.0, f"Expected 800.0, got {result}"
+
+
+def test_next_avail_vclock_returns_none_at_budget_horizon():
+    """Trace's only future transition is exactly at the budget horizon.
+
+    next_avail_after returns math.inf when there is no finite future AVL
+    transition; candidates list stays empty → None returned.
+    """
+    # The trace goes UN_AVL at 1800 (= budget). No AVL after that.
+    _AT_BUDGET = _trace((0, "AVL_TRAIN"), (1800, "UN_AVL"))
+    h = _Harness({"t1": _AT_BUDGET}, vclock_now=1800, budget=1800)
+    result = h._next_avail_vclock()
+    assert result is None, f"Expected None at budget horizon, got {result}"
+
+
+# ---------------------------------------------------------------------------
+# Starvation termination logic — directly test the decision logic
+# ---------------------------------------------------------------------------
+
+def _run_starvation_sim_branch(h):
+    """Mirror the starvation sim branch from distribute() / aggregate().
+
+    Calls _next_avail_vclock(), checks the termination condition, and sets
+    h._work_done=True if termination is warranted. Returns (_nxt, _budget).
+    """
+    _nxt = h._next_avail_vclock()
+    _budget = float(
+        getattr(h.config.hyperparameters, "max_experiment_runtime_s", float("inf"))
+    )
+    if _nxt is not None and _nxt > h._vclock.now and h._vclock.now < _budget:
+        h._vclock.advance(_nxt)
+        # (in production: refresh unavail list etc.)
+    else:
+        # Trace horizon or budget reached — stop instead of spinning.
+        h._work_done = True
+    return _nxt, _budget
+
+
+def test_starvation_terminates_when_nxt_is_none():
+    """_next_avail_vclock returns None → work_done=True, no infinite spin."""
+    h = _Harness({"t1": _EXHAUST}, vclock_now=600, budget=1800)
+    _nxt, _ = _run_starvation_sim_branch(h)
+    assert _nxt is None
+    assert h._work_done is True
+
+
+def test_starvation_terminates_when_vclock_at_budget():
+    """vclock exactly at budget → work_done=True (was: 1800>1800=False, never stopped)."""
+    # _RECOVER has AVL at 800, but vclock is already at budget (1800).
+    h = _Harness({"t1": _RECOVER}, vclock_now=1800, budget=1800)
+    _nxt, _budget = _run_starvation_sim_branch(h)
+    # _nxt could be None (no future AVL after 1800) or > 1800; either way terminates.
+    assert h._work_done is True
+
+
+def test_starvation_terminates_when_vclock_past_budget():
+    """vclock > budget → work_done=True."""
+    h = _Harness({"t1": _RECOVER}, vclock_now=1850, budget=1800)
+    _run_starvation_sim_branch(h)
+    assert h._work_done is True
+
+
+def test_starvation_advances_when_future_avail_within_budget():
+    """Normal scarcity: _nxt < budget → vclock advances, work_done stays False."""
+    h = _Harness({"t1": _RECOVER}, vclock_now=600, budget=1800)
+    _nxt, _ = _run_starvation_sim_branch(h)
+    assert _nxt == 800.0
+    assert h._vclock.now == 800.0
+    assert h._work_done is False
+
+
+# ---------------------------------------------------------------------------
+# increment_round budget check: >= (was strict >)
+# ---------------------------------------------------------------------------
+
+def test_budget_check_triggers_at_exact_equality():
+    """elapsed == budget must stop the run (>= check, not strict >).
+
+    Previously: 1800 > 1800 = False → never stopped.
+    Fixed:      1800 >= 1800 = True → stops.
+    """
+    # We test the condition directly rather than calling increment_round, which
+    # requires a full aggregator stack.  The fix is: elapsed >= budget triggers.
+    budget = 1800.0
+    elapsed = 1800.0  # exactly at budget
+    assert elapsed >= budget, "Fix regression: >= check must fire at exact equality"
+
+    # Confirm strict-> would have missed it (documents the original bug).
+    assert not (elapsed > budget), "Strict > missed this case (original bug)"
+
+
+def test_budget_check_triggers_above():
+    """elapsed > budget also stops (sanity — regression of original > behaviour)."""
+    budget = 1800.0
+    elapsed = 1801.0
+    assert elapsed >= budget
+
+
+def test_budget_check_does_not_trigger_below():
+    """elapsed < budget should NOT stop."""
+    budget = 1800.0
+    elapsed = 1799.0
+    assert not (elapsed >= budget)
diff --git a/lib/python/tests/availability/test_state_fidelity.py b/lib/python/tests/availability/test_state_fidelity.py
new file mode 100644
index 000000000..a66231ad2
--- /dev/null
+++ b/lib/python/tests/availability/test_state_fidelity.py
@@ -0,0 +1,457 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""T4 — State-fidelity tests for ClientAvailability.
+
+Deterministic, no cluster. Drives tiny synthetic traces through the mixin's
+selection-filter and delivery-ledger methods:
+
+  T-state-exact      state_at() matches the trace at every AVL/UN_AVL boundary
+  T-eval-pool        AVL_EVAL trainers excluded from train, included in eval
+  T-withhold-deliver mid-flight UN_AVL → withheld, then delivered-stale
+  T-aware-vs-reactive avail_select_filter ON vs OFF; proactive_inflight_evict
+  T-starvation-sync  exactly one vclock advance; self-terminates (B2.0.2 regression)
+"""
+
+import math
+import types
+
+import pytest
+from sortedcontainers import SortedDict
+
+from flame.availability.client_availability import ClientAvailability
+from flame.availability.trace import next_avail_after, state_at
+from flame.config import TrainerAvailState
+
+
+# ---------------------------------------------------------------------------
+# Trace builders
+# ---------------------------------------------------------------------------
+
+def _trace(*pairs):
+    d = SortedDict()
+    for ts, state in pairs:
+        d[float(ts)] = state
+    return d
+
+
+# Standard 2-state: down [300, 600), recovers at 600.
+_T1 = _trace((0, "AVL_TRAIN"), (300, "UN_AVL"), (600, "AVL_TRAIN"))
+
+# 3-state: eval-only window [200, 400).
+_T2_EVAL = _trace((0, "AVL_TRAIN"), (200, "AVL_EVAL"), (400, "AVL_TRAIN"))
+
+# Never recovers after going down.
+_NEVER = _trace((0, "AVL_TRAIN"), (300, "UN_AVL"))
+
+
+# ---------------------------------------------------------------------------
+# Stubs
+# ---------------------------------------------------------------------------
+
+class _VClock:
+    def __init__(self, now):
+        self._now = float(now)
+
+    @property
+    def now(self):
+        return self._now
+
+    def advance(self, ts):
+        if float(ts) > self._now:
+            self._now = float(ts)
+
+
+class _FakeEnd:
+    def __init__(self):
+        self.props = {}
+
+    def set_property(self, k, v):
+        self.props[k] = v
+
+    def get_property(self, k):
+        return self.props.get(k)
+
+
+class _FlatSelector:
+    """oort/refl/feddance shape: flat set, no all_selected."""
+
+    def __init__(self):
+        self.selected_ends = set()
+
+    def add(self, end):
+        self.selected_ends.add(end)
+
+
+class _Channel:
+    def __init__(self, selector, ends):
+        self._selector = selector
+        self._ends = {e: _FakeEnd() for e in ends}
+        self._props = {}
+
+    def has(self, end):
+        return end in self._ends
+
+    def set_end_property(self, end, key, value):
+        self._props[(end, key)] = value
+
+    def get_end_property(self, end, key):
+        return self._props.get((end, key))
+
+
+class _Harness(ClientAvailability):
+    """Minimal ClientAvailability host for state-fidelity tests."""
+
+    def __init__(
+        self,
+        trainer_event_dict,
+        vclock_now=0.0,
+        budget=1800.0,
+        avail_select_filter=True,
+        proactive_inflight_evict=False,
+        simulated=True,
+    ):
+        self.trainer_event_dict = trainer_event_dict
+        self._trace_has_avl_eval = bool(trainer_event_dict) and any(
+            TrainerAvailState.AVL_EVAL in trace.values()
+            for trace in trainer_event_dict.values()
+        )
+        self.pending_withheld = {}
+        self._sim_withheld_payload = {}
+        self._sim_withheld_delivering = {}
+        self.avail_select_filter = avail_select_filter
+        self.proactive_inflight_evict = proactive_inflight_evict
+        self._vclock = _VClock(vclock_now)
+        self._work_done = False
+        self._round = 1
+        self.simulated = simulated
+        self.agg_start_time_ts = 0.0
+        hp = types.SimpleNamespace(
+            max_experiment_runtime_s=budget,
+            aggregation_goal=5,
+        )
+        self.config = types.SimpleNamespace(hyperparameters=hp)
+
+    def _avail_now(self):
+        return self._vclock.now
+
+
+# ===========================================================================
+# T-state-exact
+# ===========================================================================
+
+class TestStateExact:
+    """state_at() matches the 2-state trace at every boundary, both directions."""
+
+    def _st(self, t):
+        return state_at(_T1, t)
+
+    def test_pre_window_avl_train(self):
+        assert self._st(0.0) == TrainerAvailState.AVL_TRAIN
+        assert self._st(299.9) == TrainerAvailState.AVL_TRAIN
+
+    def test_at_down_boundary_unavl(self):
+        assert self._st(300.0) == TrainerAvailState.UN_AVL
+
+    def test_inside_down_window_unavl(self):
+        assert self._st(450.0) == TrainerAvailState.UN_AVL
+        assert self._st(599.9) == TrainerAvailState.UN_AVL
+
+    def test_at_recovery_boundary_avl_train(self):
+        assert self._st(600.0) == TrainerAvailState.AVL_TRAIN
+
+    def test_post_recovery_avl_train(self):
+        assert self._st(900.0) == TrainerAvailState.AVL_TRAIN
+
+    def test_get_curr_unavail_includes_down_trainer(self):
+        h = _Harness({"t1": _T1}, vclock_now=450)
+        assert "t1" in h.get_curr_unavail_trainers()
+
+    def test_get_curr_unavail_empty_pre_window(self):
+        h = _Harness({"t1": _T1}, vclock_now=100)
+        assert h.get_curr_unavail_trainers() == []
+
+    def test_get_curr_unavail_empty_post_recovery(self):
+        h = _Harness({"t1": _T1}, vclock_now=700)
+        assert h.get_curr_unavail_trainers() == []
+
+    def test_ineligible_matches_unavail_for_2state_train(self):
+        """On a 2-state trace, ineligible('train') == unavail (no AVL_EVAL present)."""
+        h = _Harness({"t1": _T1}, vclock_now=450)
+        assert h.get_curr_task_ineligible_trainers("train") == h.get_curr_unavail_trainers()
+
+    def test_state_at_empty_trace_default_avl(self):
+        """Empty SortedDict (syn_0) → always AVL_TRAIN."""
+        assert state_at(SortedDict(), 9999.0) == TrainerAvailState.AVL_TRAIN
+
+
+# ===========================================================================
+# T-eval-pool
+# ===========================================================================
+
+class TestEvalPool:
+    """3-state trace: AVL_EVAL trainer excluded from train, included in eval."""
+
+    def _harness(self, t):
+        return _Harness(
+            {"t1": _T2_EVAL, "t2": _T1},
+            vclock_now=t,
+        )
+
+    def test_eval_trainer_excluded_from_train(self):
+        """t1 is AVL_EVAL at t=250 → excluded from 'train' dispatch."""
+        h = self._harness(250)
+        ineligible = h.get_curr_task_ineligible_trainers("train")
+        assert "t1" in ineligible
+        assert "t2" not in ineligible  # t2 is AVL_TRAIN at 250
+
+    def test_eval_trainer_not_excluded_from_eval(self):
+        """t1 is AVL_EVAL at t=250 → NOT excluded from 'eval' dispatch."""
+        h = self._harness(250)
+        assert "t1" not in h.get_curr_task_ineligible_trainers("eval")
+
+    def test_unavl_trainer_excluded_from_both(self):
+        """t2 is UN_AVL at t=400 → excluded from train AND eval."""
+        h = self._harness(400)
+        assert "t2" in h.get_curr_task_ineligible_trainers("train")
+        assert "t2" in h.get_curr_task_ineligible_trainers("eval")
+
+    def test_avl_train_trainer_eligible_for_train_not_eval(self):
+        """t2 at t=100 (AVL_TRAIN) in a 3-state trace: eligible for train only.
+        In a 3-state environment, only AVL_EVAL trainers participate in eval;
+        AVL_TRAIN trainers are excluded from eval dispatch (not UN_AVL, just wrong role).
+        """
+        h = self._harness(100)
+        assert "t2" not in h.get_curr_task_ineligible_trainers("train")
+        # AVL_TRAIN is the excluded_state for "eval" when _trace_has_avl_eval=True
+        assert "t2" in h.get_curr_task_ineligible_trainers("eval")
+
+    def test_trace_has_avl_eval_detected(self):
+        """_trace_has_avl_eval is True when any trace contains AVL_EVAL."""
+        h = self._harness(0)
+        assert h._trace_has_avl_eval is True
+
+    def test_trace_has_avl_eval_false_for_2state(self):
+        """2-state traces (AVL_TRAIN/UN_AVL only) → _trace_has_avl_eval=False."""
+        h = _Harness({"t1": _T1})
+        assert h._trace_has_avl_eval is False
+
+
+# ===========================================================================
+# T-withhold-deliver
+# ===========================================================================
+
+class TestWithholdDeliver:
+    """mid-flight UN_AVL → withheld then delivered-stale; delivery_ts is correct."""
+
+    def test_delivery_ts_when_down_at_sct(self):
+        """Trainer is UN_AVL at sct=400 → delivery waits for recovery at 600."""
+        h = _Harness({"t1": _T1})
+        assert h.compute_delivery_ts("t1", sct=400.0) == 600.0
+
+    def test_delivery_ts_immediate_when_avl_at_sct(self):
+        """Trainer is AVL_TRAIN at sct=100 → immediate delivery (= sct)."""
+        h = _Harness({"t1": _T1})
+        assert h.compute_delivery_ts("t1", sct=100.0) == 100.0
+
+    def test_delivery_ts_inf_when_never_recovers(self):
+        """Trace never recovers → math.inf (Challenge 10 guard)."""
+        h = _Harness({"t1": _NEVER})
+        assert h.compute_delivery_ts("t1", sct=400.0) == math.inf
+
+    def test_delivery_ts_at_recovery_boundary(self):
+        """sct exactly at down boundary (300) → delivery at 600 (UN_AVL at 300)."""
+        h = _Harness({"t1": _T1})
+        assert h.compute_delivery_ts("t1", sct=300.0) == 600.0
+
+    def test_free_stalled_slot_populates_ledger(self):
+        """free_stalled_slot registers delivery_ts in pending_withheld."""
+        h = _Harness({"t1": _T1}, vclock_now=0.0)
+        sel = _FlatSelector()
+        sel.add("t1")
+        ch = _Channel(sel, ["t1"])
+        delivery_ts = h.free_stalled_slot(ch, "t1", reason="test", sct=400.0)
+        assert delivery_ts == 600.0
+        assert h.pending_withheld["t1"] == 600.0
+
+    def test_withheld_held_before_delivery_ts(self):
+        """withheld_held_ends() includes end when vclock < delivery_ts."""
+        h = _Harness({"t1": _T1}, vclock_now=500)
+        h.pending_withheld["t1"] = 600.0
+        assert "t1" in h.withheld_held_ends()
+
+    def test_withheld_not_held_at_delivery_ts(self):
+        """withheld_held_ends() is empty when vclock == delivery_ts."""
+        h = _Harness({"t1": _T1}, vclock_now=600)
+        h.pending_withheld["t1"] = 600.0
+        assert "t1" not in h.withheld_held_ends()
+
+    def test_withheld_not_held_after_delivery_ts(self):
+        """withheld_held_ends() is empty when vclock > delivery_ts."""
+        h = _Harness({"t1": _T1}, vclock_now=700)
+        h.pending_withheld["t1"] = 600.0
+        assert "t1" not in h.withheld_held_ends()
+
+    def test_ready_withheld_ordered_by_delivery_ts(self):
+        """ready_withheld() returns (end, dts) sorted ascending by dts."""
+        h = _Harness({"t1": _T1, "t2": _T1}, vclock_now=700)
+        h.pending_withheld = {"t1": 600.0, "t2": 650.0}
+        due = h.ready_withheld()
+        assert [e for e, _ in due] == ["t1", "t2"]
+
+    def test_free_stalled_slot_noop_when_gate_off(self):
+        """Gate off (trainer_event_dict=None) → free_stalled_slot is a no-op."""
+        h = _Harness(None, vclock_now=0.0)
+        sel = _FlatSelector()
+        ch = _Channel(sel, [])
+        result = h.free_stalled_slot(ch, "t1", reason="test", sct=100.0)
+        assert result is None
+        assert h.pending_withheld == {}
+
+    def test_commit_withheld_removes_from_ledger(self):
+        """commit_withheld() pops the end from pending_withheld."""
+        h = _Harness({"t1": _T1})
+        h.pending_withheld["t1"] = 600.0
+        h.commit_withheld("t1")
+        assert "t1" not in h.pending_withheld
+
+
+# ===========================================================================
+# T-aware-vs-reactive
+# ===========================================================================
+
+class TestAwareVsReactive:
+    """avail_select_filter ON vs OFF; proactive_inflight_evict divergence."""
+
+    def test_select_filter_on_excludes_unavl(self):
+        h = _Harness({"t1": _T1}, vclock_now=450, avail_select_filter=True)
+        assert "t1" in h.get_curr_unavail_trainers()
+
+    def test_select_filter_off_returns_empty(self):
+        """Unaware baselines (oort/fedbuff): selection filter bypassed → empty."""
+        h = _Harness({"t1": _T1}, vclock_now=450, avail_select_filter=False)
+        assert h.get_curr_unavail_trainers() == []
+
+    def test_select_filter_off_ineligible_empty_both_tasks(self):
+        """Unaware: ineligible list always [] for both train and eval."""
+        h = _Harness({"t1": _T1}, vclock_now=450, avail_select_filter=False)
+        assert h.get_curr_task_ineligible_trainers("train") == []
+        assert h.get_curr_task_ineligible_trainers("eval") == []
+
+    def test_proactive_evict_on_frees_slot_at_boundary(self):
+        """proactive_inflight_evict=True: in-flight UN_AVL trainer is evicted."""
+        h = _Harness(
+            {"t1": _T1}, vclock_now=450,
+            avail_select_filter=True, proactive_inflight_evict=True,
+        )
+        sel = _FlatSelector()
+        sel.add("t1")  # mark t1 as in-flight
+        ch = _Channel(sel, ["t1"])
+        h._sim_evict_unavail_inflight(ch)
+        # Slot freed: t1 removed from selected_ends
+        assert "t1" not in sel.selected_ends
+        # Delivery ledger populated
+        assert "t1" in h.pending_withheld
+        assert h.pending_withheld["t1"] == 600.0
+
+    def test_proactive_evict_off_leaves_slot(self):
+        """proactive_inflight_evict=False: in-flight trainer slot untouched."""
+        h = _Harness(
+            {"t1": _T1}, vclock_now=450,
+            avail_select_filter=True, proactive_inflight_evict=False,
+        )
+        sel = _FlatSelector()
+        sel.add("t1")
+        ch = _Channel(sel, ["t1"])
+        h._sim_evict_unavail_inflight(ch)
+        # Slot NOT freed
+        assert "t1" in sel.selected_ends
+        assert "t1" not in h.pending_withheld
+
+    def test_proactive_evict_ignores_avl_trainer(self):
+        """proactive_inflight_evict=True: in-flight AVL trainer NOT evicted."""
+        h = _Harness(
+            {"t1": _T1}, vclock_now=100,  # t1 is AVL_TRAIN at t=100
+            avail_select_filter=True, proactive_inflight_evict=True,
+        )
+        sel = _FlatSelector()
+        sel.add("t1")
+        ch = _Channel(sel, ["t1"])
+        h._sim_evict_unavail_inflight(ch)
+        assert "t1" in sel.selected_ends  # slot kept
+        assert "t1" not in h.pending_withheld
+
+
+# ===========================================================================
+# T-starvation-sync
+# ===========================================================================
+
+class TestStarvationSync:
+    """Scripted scarcity → exactly one vclock advance; self-terminates (B2.0.2)."""
+
+    _EXHAUST = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"))
+    _RECOVER = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (800, "AVL_TRAIN"))
+
+    def _run_branch(self, h):
+        """Mirror the starvation sim branch: advance or set work_done."""
+        _nxt = h._next_avail_vclock()
+        _budget = float(
+            getattr(h.config.hyperparameters, "max_experiment_runtime_s", float("inf"))
+        )
+        if _nxt is not None and _nxt > h._vclock.now and h._vclock.now < _budget:
+            h._vclock.advance(_nxt)
+        else:
+            h._work_done = True
+        return _nxt
+
+    def test_single_advance_to_recovery_time(self):
+        """One starvation call → vclock jumps exactly to the recovery transition."""
+        h = _Harness({"t1": self._EXHAUST, "t2": self._RECOVER}, vclock_now=600)
+        _nxt = self._run_branch(h)
+        assert _nxt == 800.0
+        assert h._vclock.now == 800.0
+        assert h._work_done is False
+
+    def test_terminates_when_no_recovery(self):
+        """All trainers exhausted → work_done=True on first call."""
+        h = _Harness({"t1": self._EXHAUST, "t2": self._EXHAUST}, vclock_now=600)
+        _nxt = self._run_branch(h)
+        assert _nxt is None
+        assert h._work_done is True
+
+    def test_terminates_at_budget(self):
+        """vclock == budget → work_done=True (the B2.0.2 fix: >= not >)."""
+        h = _Harness({"t1": self._RECOVER}, vclock_now=1800, budget=1800)
+        self._run_branch(h)
+        assert h._work_done is True
+
+    def test_terminates_past_budget(self):
+        """vclock > budget → work_done=True."""
+        h = _Harness({"t1": self._RECOVER}, vclock_now=1850, budget=1800)
+        self._run_branch(h)
+        assert h._work_done is True
+
+    def test_next_avail_vclock_minimum_across_trainers(self):
+        """Returns the EARLIEST next recovery when multiple trainers are down."""
+        early = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (700, "AVL_TRAIN"))
+        late  = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (900, "AVL_TRAIN"))
+        h = _Harness({"t1": early, "t2": late}, vclock_now=600)
+        assert h._next_avail_vclock() == 700.0
+
+    def test_next_avail_vclock_includes_pending_withheld(self):
+        """A withheld delivery_ts is a candidate too (re-enters pool earlier)."""
+        # Both trainers exhausted, but pending_withheld shows one due at 650.
+        h = _Harness({"t1": self._EXHAUST, "t2": self._EXHAUST}, vclock_now=600)
+        h.pending_withheld["t1"] = 650.0
+        nxt = h._next_avail_vclock()
+        assert nxt == 650.0
+
+    def test_next_avail_vclock_none_when_gate_off(self):
+        """Gate off (trainer_event_dict=None) → None (no trace to scan)."""
+        h = _Harness(None, vclock_now=100)
+        assert h._next_avail_vclock() is None
+
+    def test_k1_monotone_vclock_never_goes_back(self):
+        """vclock.advance() is strictly monotone — calling it with past value is no-op."""
+        h = _Harness({"t1": self._RECOVER}, vclock_now=850)
+        h._vclock.advance(800.0)  # past value
+        assert h._vclock.now == 850.0  # unchanged
diff --git a/lib/python/tests/launch/test_baseline_wiring.py b/lib/python/tests/launch/test_baseline_wiring.py
new file mode 100644
index 000000000..3dc59a785
--- /dev/null
+++ b/lib/python/tests/launch/test_baseline_wiring.py
@@ -0,0 +1,251 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Config-gen wiring tests: verify 6-baseline matrix HP after merge.
+
+These tests catch mis-wiring before cluster time by simulating the runner's
+baseline.aggregator + experiment.config_overrides merge for each sim experiment
+in the parity YAML and asserting the correct availability flags.
+
+No subprocess spawning, no GPU, no MQTT — pure YAML/dict tests.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import yaml
+
+from flame.launch.baselines import deep_merge, load_baselines
+
+# ── Paths ─────────────────────────────────────────────────────────────────────
+_EXAMPLES = Path(__file__).parents[2] / "examples"
+_METADATA_DIR = _EXAMPLES / "_metadata"
+_PARITY_YAML = (
+    _EXAMPLES
+    / "async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml"
+)
+
+
+@pytest.fixture(scope="module")
+def baselines():
+    return load_baselines(_METADATA_DIR)
+
+
+@pytest.fixture(scope="module")
+def parity_experiments():
+    with open(_PARITY_YAML) as f:
+        data = yaml.safe_load(f)
+        return data.get("experiments", data) if isinstance(data, dict) else data
+
+
+def _sim_exp(parity_experiments, name: str) -> dict:
+    """Return the sim experiment with the given name."""
+    for exp in parity_experiments:
+        if exp["name"] == name:
+            return exp
+    raise KeyError(f"experiment {name!r} not in parity YAML")
+
+
+def _merged_hp(baselines, parity_experiments, exp_name: str, baseline_name: str) -> dict:
+    """Merge baseline.aggregator.hyperparameters with experiment config_overrides HP."""
+    bl = baselines[baseline_name]
+    bl_hp = (bl.get("aggregator") or {}).get("hyperparameters") or {}
+    exp = _sim_exp(parity_experiments, exp_name)
+    exp_hp = (
+        (exp.get("aggregator") or {})
+        .get("config_overrides", {})
+        .get("hyperparameters") or {}
+    )
+    return deep_merge(bl_hp, exp_hp)
+
+
+# ── Catalog presence ───────────────────────────────────────────────────────────
+
+class TestBaselineCatalogPresence:
+    def test_all_six_baselines_in_catalog(self, baselines):
+        required = {"felix", "oort", "oort_star", "refl", "feddance", "fedbuff"}
+        missing = required - set(baselines)
+        assert not missing, f"Missing from baselines.yaml: {missing}"
+
+    def test_oort_star_uses_oort_selector(self, baselines):
+        assert baselines["oort_star"]["aggregator"]["selector"]["sort"] == "oort"
+
+    def test_oort_star_uses_fedavg_optimizer(self, baselines):
+        assert baselines["oort_star"]["aggregator"]["optimizer"]["sort"] == "fedavg"
+
+    def test_oort_star_has_oracular_tracking(self, baselines):
+        hp = baselines["oort_star"]["aggregator"]["hyperparameters"]
+        tta = hp["trackTrainerAvail"]
+        assert tta["enabled"] == "True"
+        assert tta["type"] == "ORACULAR"
+
+    def test_all_six_baselines_in_parity_yaml(self, parity_experiments):
+        present = {e["baseline"] for e in parity_experiments if "baseline" in e}
+        required = {"felix", "oort", "oort_star", "refl", "feddance", "fedbuff"}
+        missing = required - present
+        assert not missing, f"Baselines not in parity YAML: {missing}"
+
+
+# ── Per-baseline HP verification ───────────────────────────────────────────────
+
+class TestFelixWiring:
+    def test_avail_select_filter_on(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "felix_n300_alpha0.1_syn0_stream_sim", "felix")
+        assert hp["avail_select_filter"] == "True"
+
+    def test_proactive_inflight_evict_on(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "felix_n300_alpha0.1_syn0_stream_sim", "felix")
+        assert hp["proactive_inflight_evict"] == "True"
+
+    def test_sim_unavailability_on(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "felix_n300_alpha0.1_syn0_stream_sim", "felix")
+        assert hp.get("sim_unavailability") == "True"
+
+    def test_trackTrainerAvail_disabled(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "felix_n300_alpha0.1_syn0_stream_sim", "felix")
+        tta = hp.get("trackTrainerAvail") or {}
+        assert str(tta.get("enabled", "False")).strip().lower() != "true", (
+            "felix uses client_notify, not oracular"
+        )
+
+
+class TestOortWiring:
+    def test_avail_select_filter_off(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "oort_n300_alpha0.1_syn0_stream_sim", "oort")
+        assert hp["avail_select_filter"] == "False"
+
+    def test_proactive_inflight_evict_off(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "oort_n300_alpha0.1_syn0_stream_sim", "oort")
+        assert hp["proactive_inflight_evict"] == "False"
+
+    def test_trackTrainerAvail_enabled(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "oort_n300_alpha0.1_syn0_stream_sim", "oort")
+        tta = hp.get("trackTrainerAvail") or {}
+        assert str(tta.get("enabled", "False")).strip().lower() == "true"
+        assert tta.get("type", "").upper() == "ORACULAR"
+
+    def test_trace_name_set(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "oort_n300_alpha0.1_syn0_stream_sim", "oort")
+        tta = hp.get("trackTrainerAvail") or {}
+        assert tta.get("trace"), "oort must have trackTrainerAvail.trace for starvation-advance"
+
+
+class TestOortStarWiring:
+    def test_avail_select_filter_on(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star")
+        assert hp["avail_select_filter"] == "True"
+
+    def test_proactive_inflight_evict_off(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star")
+        assert hp["proactive_inflight_evict"] == "False"
+
+    def test_trackTrainerAvail_enabled(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star")
+        tta = hp.get("trackTrainerAvail") or {}
+        assert str(tta.get("enabled", "False")).strip().lower() == "true"
+        assert tta.get("type", "").upper() == "ORACULAR"
+
+    def test_differs_from_oort_only_in_filter(self, baselines, parity_experiments):
+        oort_hp = _merged_hp(baselines, parity_experiments,
+                             "oort_n300_alpha0.1_syn0_stream_sim", "oort")
+        ostar_hp = _merged_hp(baselines, parity_experiments,
+                              "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star")
+        # avail_select_filter is the only flag that differs
+        assert oort_hp["avail_select_filter"] == "False"
+        assert ostar_hp["avail_select_filter"] == "True"
+        assert oort_hp["proactive_inflight_evict"] == ostar_hp["proactive_inflight_evict"]
+        oort_tta = oort_hp.get("trackTrainerAvail", {})
+        ostar_tta = ostar_hp.get("trackTrainerAvail", {})
+        assert oort_tta.get("enabled") == ostar_tta.get("enabled")
+        assert oort_tta.get("type") == ostar_tta.get("type")
+
+
+class TestReflWiring:
+    def test_avail_select_filter_on(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "refl_n300_alpha0.1_syn0_stream_sim", "refl")
+        assert hp["avail_select_filter"] == "True"
+
+    def test_proactive_inflight_evict_off(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "refl_n300_alpha0.1_syn0_stream_sim", "refl")
+        assert hp["proactive_inflight_evict"] == "False"
+
+    def test_trackTrainerAvail_enabled(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "refl_n300_alpha0.1_syn0_stream_sim", "refl")
+        tta = hp.get("trackTrainerAvail") or {}
+        assert str(tta.get("enabled", "False")).strip().lower() == "true"
+        assert tta.get("type", "").upper() == "ORACULAR"
+
+
+class TestFedDanceWiring:
+    def test_avail_select_filter_on(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "feddance_n300_alpha0.1_syn0_stream_sim", "feddance")
+        assert hp["avail_select_filter"] == "True"
+
+    def test_proactive_inflight_evict_off(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "feddance_n300_alpha0.1_syn0_stream_sim", "feddance")
+        assert hp["proactive_inflight_evict"] == "False"
+
+    def test_trackTrainerAvail_disabled(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "feddance_n300_alpha0.1_syn0_stream_sim", "feddance")
+        tta = hp.get("trackTrainerAvail") or {}
+        assert str(tta.get("enabled", "False")).strip().lower() != "true", (
+            "feddance has its own check-in predictor, not oracular"
+        )
+
+
+class TestFedBuffWiring:
+    def test_avail_select_filter_off(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff")
+        assert hp["avail_select_filter"] == "False"
+
+    def test_proactive_inflight_evict_off(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff")
+        assert hp["proactive_inflight_evict"] == "False"
+
+    def test_sim_unavailability_on(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff")
+        assert hp.get("sim_unavailability") == "True", (
+            "fedbuff must activate the availability gate via sim_unavailability "
+            "(unaware baseline: gate loads trace but does not filter selection pool)"
+        )
+
+    def test_availability_trace_set(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff")
+        has_trace = (
+            hp.get("availability_trace")
+            or (hp.get("client_notify") or {}).get("trace")
+        )
+        assert has_trace, (
+            "fedbuff must have availability_trace (or client_notify.trace) so "
+            "_init_availability can load the syn_0 trace without warning"
+        )
+
+    def test_trackTrainerAvail_disabled(self, baselines, parity_experiments):
+        hp = _merged_hp(baselines, parity_experiments,
+                        "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff")
+        tta = hp.get("trackTrainerAvail") or {}
+        assert str(tta.get("enabled", "False")).strip().lower() != "true", (
+            "fedbuff should not use oracular tracking"
+        )
diff --git a/lib/python/tests/launch/test_config_generator.py b/lib/python/tests/launch/test_config_generator.py
index ac6514de3..8686fc595 100644
--- a/lib/python/tests/launch/test_config_generator.py
+++ b/lib/python/tests/launch/test_config_generator.py
@@ -368,3 +368,47 @@ def test_spawn_all_defaults_match_generate_trainer_config_defaults(
         assert gen.calls == [
             {"trainer_id": 1, "dataset_name": "cifar10", "num_trainers": 300}
         ]
+
+
+class TestSyntheticTracePerTrainer:
+    """Regression for Open B (UNAVAILABILITY_DESIGN.md): get_synthetic_trace used
+    to always return the shared `pattern` entry regardless of trainer_id,
+    ignoring synthetic_traces.yaml's per-trainer entries. trainer_054's own
+    trace (first event t=13800s) differs from syn_20's shared pattern
+    (t=600s)."""
+
+    def test_shared_pattern_when_trainer_id_omitted(self, loader):
+        pattern = loader.get_synthetic_trace("syn_20")
+        assert pattern[0] == [0, "AVL_TRAIN"]
+        assert pattern[1][0] == 600
+
+    def test_per_trainer_used_when_trainer_id_given(self, loader):
+        trace_054 = loader.get_synthetic_trace("syn_20", trainer_id=54)
+        pattern = loader.get_synthetic_trace("syn_20")
+        assert trace_054 != pattern
+        assert trace_054[0] == [0.0, "AVL_TRAIN"]
+        assert trace_054[1][0] == 13800
+
+    def test_different_trainers_get_different_traces(self, loader):
+        trace_054 = loader.get_synthetic_trace("syn_20", trainer_id=54)
+        trace_005 = loader.get_synthetic_trace("syn_20", trainer_id=5)
+        assert trace_054 != trace_005
+
+    def test_generate_trainer_config_bakes_in_per_trainer_trace(self, gen):
+        cfg = gen.generate_trainer_config(
+            trainer_id=54, alpha=0.1, availability_mode="syn_20"
+        )
+        events = cfg["hyperparameters"]["avl_events_syn_20"]
+        assert events[1][0] == 13800
+
+    def test_generate_trainer_config_differs_across_trainers(self, gen):
+        cfg_054 = gen.generate_trainer_config(
+            trainer_id=54, alpha=0.1, availability_mode="syn_20"
+        )
+        cfg_005 = gen.generate_trainer_config(
+            trainer_id=5, alpha=0.1, availability_mode="syn_20"
+        )
+        assert (
+            cfg_054["hyperparameters"]["avl_events_syn_20"]
+            != cfg_005["hyperparameters"]["avl_events_syn_20"]
+        )
diff --git a/lib/python/tests/launch/test_debug_run_trace_substitution.py b/lib/python/tests/launch/test_debug_run_trace_substitution.py
new file mode 100644
index 000000000..03b79c534
--- /dev/null
+++ b/lib/python/tests/launch/test_debug_run_trace_substitution.py
@@ -0,0 +1,176 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Regression coverage for debug_run.sh's `--trace` substitution.
+
+`make_debug_yaml`'s generator is Python embedded in a bash heredoc (no
+importable module exists for it), so these tests extract and exec the actual
+heredoc source out of debug_run.sh itself -- never a hand-copied
+reimplementation that could silently drift from what actually runs.
+
+Regression target: the generator used to patch the *aggregator's* trace
+config (`h["trackTrainerAvail"]["trace"]` / `h["client_notify"]["trace"]` /
+`h["availability_trace"]`) on `--trace` override, but never touched the
+*trainer's* `hyperparameters.client_notify.trace` -- so every trainer, real
+and sim, silently ran against the trainer_base.yaml default (`syn_0`,
+always-available) regardless of the requested trace. See
+UNAVAILABILITY_DESIGN.md Batch 3 T3.1.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+import pytest
+import yaml
+
+_DEBUG_RUN_SH = (
+    Path(__file__).parents[2]
+    / "examples/async_cifar10/scripts/debug_run.sh"
+)
+_SCR_DIR = (
+    Path(__file__).parents[2]
+    / "examples/async_cifar10/expt_scripts_2026"
+)
+
+
+def _extract_make_debug_yaml_source() -> str:
+    """Pull the Python heredoc body of make_debug_yaml() out of debug_run.sh."""
+    text = _DEBUG_RUN_SH.read_text(encoding="utf-8")
+    m = re.search(
+        r"make_debug_yaml\(\) \{.*?<<'PY'\n(.*?)\nPY\n", text, re.DOTALL
+    )
+    assert m, "could not locate make_debug_yaml()'s PY heredoc in debug_run.sh"
+    return m.group(1)
+
+
+@pytest.fixture(scope="module")
+def generator_source() -> str:
+    return _extract_make_debug_yaml_source()
+
+
+def _run_generator(
+    source: str,
+    tmp_path: Path,
+    baselines: str,
+    trace: str,
+    mode: str = "both",
+    runtime_s: int = 100,
+) -> list[dict]:
+    """Exec the extracted generator with a controlled argv; return experiments."""
+    outpath = tmp_path / "out.yaml"
+    argv = [
+        "make_debug_yaml",
+        str(_SCR_DIR),
+        baselines,
+        str(runtime_s),
+        str(outpath),
+        "0",  # smoke
+        "",  # sim_wall_ceiling_s
+        mode,
+        trace,
+        "",  # num_trainers override
+    ]
+    old_argv = sys.argv
+    sys.argv = argv
+    try:
+        exec(compile(source, "make_debug_yaml<heredoc>", "exec"), {})
+    finally:
+        sys.argv = old_argv
+    assert outpath.is_file(), "generator produced no output (no baseline matched?)"
+    with open(outpath) as f:
+        return yaml.safe_load(f)["experiments"]
+
+
+class TestTrainerTraceSubstitution:
+    """The bug: trainer.config_overrides.hyperparameters.client_notify.trace
+    must track --trace, independent of which aggregator-side branch (legacy
+    trackTrainerAvail / HP-level client_notify / availability_trace) a given
+    baseline takes."""
+
+    @pytest.mark.parametrize(
+        "baseline",
+        ["felix", "oort", "oort_star", "refl", "feddance", "fedbuff"],
+    )
+    def test_trainer_client_notify_trace_matches_override(
+        self, generator_source, tmp_path, baseline
+    ):
+        exps = _run_generator(generator_source, tmp_path, baseline, trace="syn_20")
+        assert exps, f"no experiments generated for baseline={baseline}"
+        for exp in exps:
+            trace = (
+                exp["trainer"]["config_overrides"]["hyperparameters"]
+                ["client_notify"]["trace"]
+            )
+            assert trace == "syn_20", (
+                f"{exp['name']}: trainer client_notify.trace={trace!r}, "
+                f"expected 'syn_20' (--trace override was not propagated to "
+                f"the trainer)"
+            )
+
+    def test_trainer_client_notify_trace_tracks_different_overrides(
+        self, generator_source, tmp_path
+    ):
+        for trace in ("syn_0", "syn_20", "syn_50"):
+            exps = _run_generator(
+                generator_source, tmp_path, "feddance", trace=trace
+            )
+            for exp in exps:
+                got = (
+                    exp["trainer"]["config_overrides"]["hyperparameters"]
+                    ["client_notify"]["trace"]
+                )
+                assert got == trace, f"{exp['name']}: expected {trace!r}, got {got!r}"
+
+    def test_no_trace_override_leaves_trainer_config_untouched(
+        self, generator_source, tmp_path
+    ):
+        """No --trace: don't inject a client_notify block that wasn't there."""
+        exps = _run_generator(generator_source, tmp_path, "feddance", trace="")
+        for exp in exps:
+            t_hp = exp["trainer"].get("config_overrides", {}).get("hyperparameters", {})
+            assert "client_notify" not in t_hp
+
+    def test_aggregator_trace_still_substituted(self, generator_source, tmp_path):
+        """Regression guard: fixing the trainer side must not break the
+        pre-existing aggregator-side substitution paths."""
+        exps = _run_generator(generator_source, tmp_path, "feddance", trace="syn_50")
+        for exp in exps:
+            h = exp["aggregator"]["config_overrides"]["hyperparameters"]
+            assert h.get("availability_trace") == "syn_50"
+            assert h.get("simUnavailability") is True
+
+        exps = _run_generator(generator_source, tmp_path, "oort", trace="syn_50")
+        for exp in exps:
+            h = exp["aggregator"]["config_overrides"]["hyperparameters"]
+            assert h["trackTrainerAvail"]["trace"] == "syn_50"
+
+
+class TestMultiTraceSubstitution:
+    """--trace accepts a space-separated list: one full experiment set per
+    trace, queued in a single generated YAML/run."""
+
+    def test_two_traces_double_the_experiment_count(self, generator_source, tmp_path):
+        single = _run_generator(generator_source, tmp_path, "felix", trace="syn_20")
+        both = _run_generator(generator_source, tmp_path, "felix", trace="syn_20 syn_50")
+        assert len(both) == 2 * len(single)
+
+    def test_each_trace_propagates_to_its_own_experiments(
+        self, generator_source, tmp_path
+    ):
+        exps = _run_generator(generator_source, tmp_path, "felix", trace="syn_20 syn_50")
+        by_trace = {
+            trace: [
+                e for e in exps
+                if e["trainer"]["config_overrides"]["hyperparameters"]
+                ["client_notify"]["trace"] == trace
+            ]
+            for trace in ("syn_20", "syn_50")
+        }
+        assert len(by_trace["syn_20"]) == len(by_trace["syn_50"]) == len(exps) // 2
+
+    def test_experiment_names_disambiguate_by_trace(self, generator_source, tmp_path):
+        exps = _run_generator(generator_source, tmp_path, "felix", trace="syn_20 syn_50")
+        names = [e["name"] for e in exps]
+        assert len(names) == len(set(names)), f"duplicate names: {names}"
diff --git a/lib/python/tests/mode/test_agg_start_ts_broadcast.py b/lib/python/tests/mode/test_agg_start_ts_broadcast.py
new file mode 100644
index 000000000..b705af7b4
--- /dev/null
+++ b/lib/python/tests/mode/test_agg_start_ts_broadcast.py
@@ -0,0 +1,288 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.0: broadcast the aggregator's trace-read origin to trainers.
+
+Real mode's `_avail_now()`/`_sim_now()`-equivalent needs a SHARED origin
+between aggregator and trainer, exactly like sim's shared `_vclock` instance.
+Before this, a real-mode trainer had no way to know `agg_start_time_ts` (the
+join-barrier-reanchored origin, see test_join_barrier_reanchor.py) at all, so
+any trainer-side wall-clock trace lookup would have had to derive its own
+origin (e.g. its own process-start time) -- reintroducing a per-trainer
+join-ramp-style skew, the same class of bug as B2.0.3 just moved to the
+trainer side. `MessageType.AGG_START_TS` closes that: the aggregator stamps
+it on every real-mode dispatch (mirroring how `SIM_SEND_TS` is stamped for
+sim), and the trainer caches it, using it as the origin for `_sim_now()`'s
+real-mode branch instead of `trainer_start_ts`.
+"""
+
+from __future__ import annotations
+
+import types
+
+import pytest
+
+from flame.mode.message import MessageType
+
+
+# ── Minimal channel mocks (mirrors tests/mode/test_async_staggered_redispatch.py) ──
+
+class _DistChannel:
+    """Records every dispatched payload/property, no real transport."""
+
+    def __init__(self, ends):
+        self._ends = {e: None for e in ends}
+        self.properties = {}
+        self.props = {}
+        self.sent = {}
+        self._selector = types.SimpleNamespace(selected_ends=set())
+
+    def await_join(self):
+        pass
+
+    def ends(self, state, task=None, **kw):
+        return list(self._ends.keys())
+
+    def dumps(self, msg):
+        return dict(msg)
+
+    def send_payload(self, end, payload):
+        self.sent[end] = payload
+
+    def set_end_property(self, end, key, value):
+        self.props.setdefault(end, {})[key] = value
+
+    def set_curr_unavailable_trainers(self, trainer_unavail_list=None):
+        self.unavail = list(trainer_unavail_list or [])
+
+
+def _stub_common(agg, channel, *, simulated):
+    agg.simulated = simulated
+    agg.agg_start_time_ts = 1_700_000_000.0
+    agg._round = 3
+    agg.trainer_event_dict = None  # gate off: skip the oracular unavailable-list path
+    agg.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel)
+    agg._await_min_trainers = lambda ch: None
+    agg._update_weights = lambda: None
+    agg._inject_oracle_utilities = lambda ch, task: None
+    agg._avail_stamp_end_states = lambda ch: None
+    agg._avail_now = lambda: 0.0
+    agg._sim_abandon_stalled = lambda ch: None
+    agg._sim_evict_unavail_inflight = lambda ch: None
+    agg.datasampler = types.SimpleNamespace(get_metadata=lambda r, e: {})
+    agg.weights = {}
+
+
+def _make_syncfl_agg(channel, *, simulated):
+    from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator
+
+    class _Concrete(TopAggregator):
+        def check_and_sleep(self):
+            pass
+
+        def evaluate(self):
+            pass
+
+        def initialize(self):
+            pass
+
+        def load_data(self):
+            pass
+
+        def train(self):
+            pass
+
+    agg = _Concrete.__new__(_Concrete)
+    _stub_common(agg, channel, simulated=simulated)
+    agg.config = types.SimpleNamespace(
+        hyperparameters=types.SimpleNamespace(aggregation_goal=1)
+    )
+    return agg
+
+
+def _make_oort_agg(channel, *, simulated):
+    from flame.mode.horizontal.oort.top_aggregator import TopAggregator
+
+    class _Concrete(TopAggregator):
+        def check_and_sleep(self):
+            pass
+
+        def evaluate(self):
+            pass
+
+        def initialize(self):
+            pass
+
+        def load_data(self):
+            pass
+
+        def train(self):
+            pass
+
+    agg = _Concrete.__new__(_Concrete)
+    _stub_common(agg, channel, simulated=simulated)
+    agg.config = types.SimpleNamespace(
+        selector=types.SimpleNamespace(kwargs={"aggr_num": 1}),
+        hyperparameters=types.SimpleNamespace(sim_inflight_residence=False),
+    )
+    return agg
+
+
+@pytest.fixture(autouse=True)
+def _identity_weights(monkeypatch):
+    import flame.mode.horizontal.syncfl.top_aggregator as syncfl_mod
+    import flame.mode.horizontal.oort.top_aggregator as oort_mod
+
+    monkeypatch.setattr(syncfl_mod, "weights_to_device", lambda w, d: w)
+    monkeypatch.setattr(oort_mod, "weights_to_device", lambda w, d: w)
+
+
+class TestAggregatorBroadcastsOrigin:
+    """Every real-mode dispatch carries AGG_START_TS; sim never does."""
+
+    def test_syncfl_real_mode_stamps_agg_start_ts(self):
+        ch = _DistChannel(["e1", "e2"])
+        agg = _make_syncfl_agg(ch, simulated=False)
+        agg._distribute_weights("tag", "train")
+        assert ch.sent["e1"][MessageType.AGG_START_TS] == agg.agg_start_time_ts
+        assert ch.sent["e2"][MessageType.AGG_START_TS] == agg.agg_start_time_ts
+        assert MessageType.SIM_SEND_TS not in ch.sent["e1"]
+
+    def test_syncfl_sim_mode_never_stamps_agg_start_ts(self):
+        from flame.sim import VirtualClock
+
+        ch = _DistChannel(["e1", "e2"])
+        agg = _make_syncfl_agg(ch, simulated=True)
+        agg._vclock = VirtualClock()
+        agg._vclock.advance(42.0)
+        agg._distribute_weights("tag", "train")
+        assert MessageType.AGG_START_TS not in ch.sent["e1"]
+        assert ch.sent["e1"][MessageType.SIM_SEND_TS] == 42.0
+
+    def test_oort_real_mode_stamps_agg_start_ts(self):
+        ch = _DistChannel(["e1", "e2"])
+        agg = _make_oort_agg(ch, simulated=False)
+        agg._distribute_weights("tag", "train")
+        assert ch.sent["e1"][MessageType.AGG_START_TS] == agg.agg_start_time_ts
+        assert MessageType.SIM_SEND_TS not in ch.sent["e1"]
+
+    def test_oort_sim_mode_never_stamps_agg_start_ts(self):
+        from flame.sim import VirtualClock
+
+        ch = _DistChannel(["e1", "e2"])
+        agg = _make_oort_agg(ch, simulated=True)
+        agg._vclock = VirtualClock()
+        agg._vclock.advance(17.0)
+        agg._distribute_weights("tag", "train")
+        assert MessageType.AGG_START_TS not in ch.sent["e1"]
+        assert ch.sent["e1"][MessageType.SIM_SEND_TS] == 17.0
+
+    def test_asyncfl_real_mode_stamps_agg_start_ts(self):
+        # asyncfl's staggered path is sim-only (_staggered requires
+        # self.simulated); real mode always takes the shared/batched branch,
+        # so it's enough to exercise that one.
+        from flame.mode.horizontal.asyncfl.top_aggregator import TopAggregator
+        from flame.sim import VirtualClock
+
+        class _Concrete(TopAggregator):
+            def check_and_sleep(self):
+                pass
+
+            def evaluate(self):
+                pass
+
+            def initialize(self):
+                pass
+
+            def load_data(self):
+                pass
+
+            def train(self):
+                pass
+
+        ch = _DistChannel(["e1", "e2"])
+        agg = _Concrete.__new__(_Concrete)
+        _stub_common(agg, ch, simulated=False)
+        agg._vclock = VirtualClock()
+        agg._sim_staggered_redispatch = False
+        agg._sim_inflight_residence = False
+        agg._sim_free_slot_ts = __import__("collections").deque(maxlen=128)
+        agg._sim_last_commit_sct = {}
+        agg._sim_inflight_expected = {}
+        agg._sim_trainer_budget = {}
+        agg._sim_budget_min = 12.0
+        agg._sim_redispatch_gap_s = 0.0
+        agg._sim_cooldown_until = {}
+        agg._real_distribute_settle_s = 0.0
+        agg._track_trainer_version_duration_s = {}
+        agg.weights = {}
+        agg._distribute_weights("tag", "train")
+        assert ch.sent["e1"][MessageType.AGG_START_TS] == agg.agg_start_time_ts
+
+
+class TestTrainerCachesOrigin:
+    """syncfl/trainer.py's message handling caches AGG_START_TS (real mode)."""
+
+    def _make_trainer(self):
+        from flame.mode.horizontal.syncfl.trainer import Trainer
+
+        class _Concrete(Trainer):
+            def check_and_sleep(self):
+                pass
+
+            def evaluate(self):
+                pass
+
+            def initialize(self):
+                pass
+
+            def load_data(self):
+                pass
+
+            def train(self):
+                pass
+
+        t = _Concrete.__new__(_Concrete)
+        t.trainer_id = "trainer-under-test"
+        t._round = 0
+        t._work_done = False
+        t.task_to_perform = "train"
+        t._agg_start_origin = None
+        return t
+
+    def _fetch(self, trainer, msg):
+        """Drive _fetch_weights with a minimal channel (no WEIGHTS payload,
+        so the torch-dependent model-loading branch is never entered)."""
+        selector = types.SimpleNamespace(ordered_updates_recv_ends=[])
+        channel = types.SimpleNamespace(
+            _selector=selector,
+            await_join=lambda: None,
+            one_end=lambda state: "agg-end",
+            recv=lambda end: (msg, None),
+            cleanup_recvd_ends=lambda: None,
+        )
+        trainer.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel)
+        trainer._fetch_weights("tag")
+
+    def test_caches_agg_start_ts_from_message(self):
+        t = self._make_trainer()
+        origin = 1_700_000_123.456
+        self._fetch(t, {MessageType.ROUND: 1, MessageType.AGG_START_TS: origin})
+        assert t._agg_start_origin == origin
+
+    def test_no_agg_start_ts_in_message_leaves_cache_untouched(self):
+        t = self._make_trainer()
+        t._agg_start_origin = 111.0
+        self._fetch(t, {MessageType.ROUND: 1})
+        assert t._agg_start_origin == 111.0  # unchanged, not reset to None
+
+    def test_re_caches_on_every_dispatch(self):
+        t = self._make_trainer()
+        self._fetch(t, {MessageType.ROUND: 1, MessageType.AGG_START_TS: 100.0})
+        assert t._agg_start_origin == 100.0
+        self._fetch(t, {MessageType.ROUND: 2, MessageType.AGG_START_TS: 100.0})
+        assert t._agg_start_origin == 100.0
+
+
+# PyTorchCifar10Trainer._sim_now()'s real-mode branch is example-specific code
+# (examples/async_cifar10/trainer/pytorch/main.py), not core flame -- see
+# examples/async_cifar10/trainer/pytorch/test_agg_start_ts_sim_now.py.
diff --git a/lib/python/tests/mode/test_async_staggered_redispatch.py b/lib/python/tests/mode/test_async_staggered_redispatch.py
index b4719ca8f..bda8ed6ae 100644
--- a/lib/python/tests/mode/test_async_staggered_redispatch.py
+++ b/lib/python/tests/mode/test_async_staggered_redispatch.py
@@ -13,6 +13,7 @@
 """
 
 import inspect
+import time
 import types
 from collections import deque
 
@@ -98,7 +99,7 @@ def __init__(self, send_ends):
     def await_join(self):
         pass
 
-    def ends(self, state, task=None):
+    def ends(self, state, task=None, agg_version_state=None, trainer_version_states=None):
         return list(self._send_ends)
 
     def dumps(self, msg):
@@ -120,6 +121,7 @@ def has(self, end):
 def _make_dist_agg(channel, *, staggered, simulated=True, free_slots=()):
     agg = _ConcreteAgg.__new__(_ConcreteAgg)
     agg.simulated = simulated
+    agg.agg_start_time_ts = time.time()
     agg._round = 5
     agg._vclock = VirtualClock()
     agg._vclock.advance(100.0)
diff --git a/lib/python/tests/mode/test_eot_avail_catchup.py b/lib/python/tests/mode/test_eot_avail_catchup.py
new file mode 100644
index 000000000..a26df27a6
--- /dev/null
+++ b/lib/python/tests/mode/test_eot_avail_catchup.py
@@ -0,0 +1,161 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 4 finding 2 (UNAVAILABILITY_DESIGN.md): a sim-mode trainer that goes
+quiet (correctly withheld/evicted as UN_AVL, so never dispatched again) has a
+frozen `_sim_now()` and so can never catch its `avail_change` telemetry up to
+later trace transitions on its own. `inform_end_of_training`'s existing
+`channel.broadcast(...)` already reaches every connected end regardless of
+dispatch state, so it now piggybacks the aggregator's final `_avail_now()`
+(gated on sim mode + the availability feature being on, so the broadcast
+payload is byte-identical when off) -- one last wake-up letting
+`_refresh_avl_state()` flush any queued transitions before the trainer exits.
+
+Two halves, mirroring test_agg_start_ts_broadcast.py's structure:
+  * aggregator side: inform_end_of_training's broadcast payload.
+  * trainer side: _fetch_weights calls _refresh_avl_state() on EOT receipt.
+"""
+
+from __future__ import annotations
+
+import types
+
+import pytest
+
+from flame.mode.message import MessageType
+
+
+# ---- Aggregator side -------------------------------------------------------
+
+class _BroadcastChannel:
+    """Records the last broadcast payload, no real transport."""
+
+    def __init__(self):
+        self.broadcasts = []
+
+    def broadcast(self, payload):
+        self.broadcasts.append(dict(payload))
+
+
+def _make_syncfl_agg(*, simulated, gate_on, vclock_now=42.0):
+    from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator
+    from flame.sim import VirtualClock
+
+    class _Concrete(TopAggregator):
+        def check_and_sleep(self):
+            pass
+
+        def evaluate(self):
+            pass
+
+        def initialize(self):
+            pass
+
+        def load_data(self):
+            pass
+
+        def train(self):
+            pass
+
+    agg = _Concrete.__new__(_Concrete)
+    agg.simulated = simulated
+    agg._work_done = True
+    agg.trainer_event_dict = {"e1": object()} if gate_on else None
+    agg.agg_start_time_ts = 1_700_000_000.0
+    channel = _BroadcastChannel()
+    agg.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel)
+    agg.dist_tag = "tag"
+    if simulated:
+        agg._vclock = VirtualClock()
+        agg._vclock.advance(vclock_now)
+    return agg, channel
+
+
+class TestInformEndOfTrainingCarriesFinalClock:
+    def test_sim_mode_gate_on_carries_sim_send_ts(self):
+        agg, ch = _make_syncfl_agg(simulated=True, gate_on=True, vclock_now=77.0)
+        agg.inform_end_of_training()
+        assert ch.broadcasts[0][MessageType.SIM_SEND_TS] == 77.0
+        assert ch.broadcasts[0][MessageType.EOT] is True
+
+    def test_sim_mode_gate_off_omits_sim_send_ts(self):
+        """Byte-identical broadcast payload when the availability feature is off."""
+        agg, ch = _make_syncfl_agg(simulated=True, gate_on=False)
+        agg.inform_end_of_training()
+        assert MessageType.SIM_SEND_TS not in ch.broadcasts[0]
+        assert ch.broadcasts[0] == {MessageType.EOT: True}
+
+    def test_real_mode_omits_sim_send_ts(self):
+        """Real mode's clock never freezes -- no catch-up broadcast needed."""
+        agg, ch = _make_syncfl_agg(simulated=False, gate_on=True)
+        agg.inform_end_of_training()
+        assert MessageType.SIM_SEND_TS not in ch.broadcasts[0]
+        assert ch.broadcasts[0] == {MessageType.EOT: True}
+
+
+# ---- Trainer side -----------------------------------------------------------
+
+class TestTrainerFlushesCatchupOnEot:
+    def _make_trainer(self, *, with_refresh_hook):
+        from flame.mode.horizontal.syncfl.trainer import Trainer
+
+        class _Concrete(Trainer):
+            def check_and_sleep(self):
+                pass
+
+            def evaluate(self):
+                pass
+
+            def initialize(self):
+                pass
+
+            def load_data(self):
+                pass
+
+            def train(self):
+                pass
+
+        t = _Concrete.__new__(_Concrete)
+        t.trainer_id = "trainer-under-test"
+        t._round = 0
+        t._work_done = False
+        t.task_to_perform = "train"
+        t._agg_start_origin = None
+        if with_refresh_hook:
+            t._refresh_calls = 0
+
+            def _refresh():
+                t._refresh_calls += 1
+
+            t._refresh_avl_state = _refresh
+        return t
+
+    def _fetch(self, trainer, msg):
+        selector = types.SimpleNamespace(ordered_updates_recv_ends=[])
+        channel = types.SimpleNamespace(
+            _selector=selector,
+            await_join=lambda: None,
+            one_end=lambda state: "agg-end",
+            recv=lambda end: (msg, None),
+            cleanup_recvd_ends=lambda: None,
+        )
+        trainer.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel)
+        trainer._fetch_weights("tag")
+
+    def test_eot_triggers_refresh_when_hook_present(self):
+        t = self._make_trainer(with_refresh_hook=True)
+        self._fetch(t, {MessageType.EOT: True, MessageType.SIM_SEND_TS: 900.0})
+        assert t._work_done is True
+        assert t._refresh_calls == 1
+
+    def test_eot_without_hook_is_safe_noop(self):
+        """Not every Trainer subclass defines _refresh_avl_state (example-
+        specific) -- the hasattr guard must not raise for those."""
+        t = self._make_trainer(with_refresh_hook=False)
+        assert not hasattr(t, "_refresh_avl_state")
+        self._fetch(t, {MessageType.EOT: True})  # must not raise
+        assert t._work_done is True
+
+    def test_non_eot_message_does_not_trigger_refresh(self):
+        t = self._make_trainer(with_refresh_hook=True)
+        self._fetch(t, {MessageType.ROUND: 3})
+        assert t._refresh_calls == 0
diff --git a/lib/python/tests/mode/test_fwdllm_agg_telemetry.py b/lib/python/tests/mode/test_fwdllm_agg_telemetry.py
index 03c786e90..c5300be37 100644
--- a/lib/python/tests/mode/test_fwdllm_agg_telemetry.py
+++ b/lib/python/tests/mode/test_fwdllm_agg_telemetry.py
@@ -24,6 +24,7 @@
     TopAggregator,
 )
 from flame.mode.message import MessageType
+from flame.selector.properties import PROP_CLIENT_TASK_TRAIN_DURATION
 
 
 class _FakeChannel:
@@ -34,9 +35,9 @@ def __init__(self, durations=None, utilities=None):
         self.round_prop = None
 
     def get_end_property(self, end, key):
-        if key == "round_duration":
+        if key == PROP_CLIENT_TASK_TRAIN_DURATION:
             return self._durations.get(end)
-        if key == "stat_utility":
+        if key == PROP_STAT_UTILITY:
             return self._utilities.get(end)
         return None
 
diff --git a/lib/python/tests/mode/test_join_barrier_reanchor.py b/lib/python/tests/mode/test_join_barrier_reanchor.py
new file mode 100644
index 000000000..4138281c2
--- /dev/null
+++ b/lib/python/tests/mode/test_join_barrier_reanchor.py
@@ -0,0 +1,112 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Real-mode agg_start_time_ts re-anchor at the join barrier.
+
+`agg_start_time_ts` is stamped at aggregator __init__, before the trainer
+cohort joins. In sim mode this is harmless (_avail_now() reads _vclock.now,
+which only starts advancing at round-0 selection). In real mode _avail_now()
+reads time.time() - agg_start_time_ts, so without a re-anchor the join wait
+(real OS process spawn/connect — ~300s wall at n=300) is silently baked into
+every subsequent availability-trace read: real ends up reading the trace
+~300s ahead of where sim/ground-truth says it should be (root-caused via
+feddance syn_50 A3 — see UNAVAILABILITY_DESIGN.md).
+
+`_mark_join_barrier_done` fixes this by re-anchoring agg_start_time_ts to
+"now" (real mode only) at the moment the join barrier resolves, whatever
+that wait actually took — self-correcting if the join wait duration changes.
+"""
+
+import time
+import types
+
+from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator
+
+
+class _ConcreteAgg(TopAggregator):
+    def check_and_sleep(self):
+        pass
+
+    def evaluate(self):
+        pass
+
+    def initialize(self):
+        pass
+
+    def load_data(self):
+        pass
+
+    def train(self):
+        pass
+
+
+def _make_agg(*, simulated: bool, min_trainers_to_start=None, n_joined=0):
+    agg = _ConcreteAgg.__new__(_ConcreteAgg)
+    agg.simulated = simulated
+    agg.config = types.SimpleNamespace(
+        hyperparameters=types.SimpleNamespace(
+            min_trainers_to_start=min_trainers_to_start,
+            min_trainers_join_timeout_s=5.0,
+        )
+    )
+    agg.agg_start_time_ts = time.time()
+    channel = types.SimpleNamespace(_ends={f"t{i}": None for i in range(n_joined)})
+    return agg, channel
+
+
+class TestMarkJoinBarrierDone:
+    def test_real_mode_reanchors_agg_start(self):
+        agg, _ = _make_agg(simulated=False)
+        original = agg.agg_start_time_ts
+        time.sleep(0.02)
+        agg._mark_join_barrier_done()
+        assert agg._join_barrier_done is True
+        assert agg.agg_start_time_ts > original
+
+    def test_sim_mode_leaves_agg_start_untouched(self):
+        agg, _ = _make_agg(simulated=True)
+        original = agg.agg_start_time_ts
+        time.sleep(0.02)
+        agg._mark_join_barrier_done()
+        assert agg._join_barrier_done is True
+        assert agg.agg_start_time_ts == original
+
+
+class TestAwaitMinTrainersReanchors:
+    def test_real_mode_barrier_disabled_still_reanchors(self):
+        # min_trainers_to_start unset → barrier is a no-op wait, but the join
+        # (channel.await_join(), called by the caller before this) still cost
+        # real wall-clock time, so agg_start_time_ts must still move.
+        agg, channel = _make_agg(simulated=False, min_trainers_to_start=None)
+        original = agg.agg_start_time_ts
+        time.sleep(0.02)
+        agg._await_min_trainers(channel)
+        assert agg.agg_start_time_ts > original
+
+    def test_real_mode_barrier_satisfied_reanchors_after_wait(self):
+        agg, channel = _make_agg(
+            simulated=False, min_trainers_to_start=3, n_joined=3
+        )
+        original = agg.agg_start_time_ts
+        time.sleep(0.02)
+        agg._await_min_trainers(channel)
+        assert agg._join_barrier_done is True
+        assert agg.agg_start_time_ts > original
+
+    def test_sim_mode_never_reanchors(self):
+        agg, channel = _make_agg(
+            simulated=True, min_trainers_to_start=3, n_joined=3
+        )
+        original = agg.agg_start_time_ts
+        time.sleep(0.02)
+        agg._await_min_trainers(channel)
+        assert agg.agg_start_time_ts == original
+
+    def test_one_shot_does_not_reanchor_twice(self):
+        agg, channel = _make_agg(
+            simulated=False, min_trainers_to_start=3, n_joined=3
+        )
+        agg._await_min_trainers(channel)
+        anchored = agg.agg_start_time_ts
+        time.sleep(0.02)
+        agg._await_min_trainers(channel)  # second call: already done, no-op
+        assert agg.agg_start_time_ts == anchored
diff --git a/lib/python/tests/mode/test_proactive_evict_call_site.py b/lib/python/tests/mode/test_proactive_evict_call_site.py
new file mode 100644
index 000000000..b4cc4e89f
--- /dev/null
+++ b/lib/python/tests/mode/test_proactive_evict_call_site.py
@@ -0,0 +1,244 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 4 finding 1: D.1 proactive in-flight eviction must run in real mode too.
+
+`_sim_evict_unavail_inflight` (D.1, felix-only via `proactive_inflight_evict`)
+has no vclock/sim dependency -- it reads `_avail_now()` (mode-dispatching
+already) and the selector's own `selected_ends`, both equally valid in real
+mode. It used to be called only inside `if self.simulated:` alongside
+`_sim_abandon_stalled` (which genuinely IS sim-only: real mode has its own
+native wall-clock abandon in the selector, `SEND_TIMEOUT_WAIT_S`). That left
+real-mode felix runs with no way to drop a stalled UN_AVL trainer out of
+`selected_ends` (and therefore out of `channel.ends(VAL_CH_STATE_RECV)`,
+since `async_oort`'s selector derives recv-state ends directly from
+`selected_ends`) -- the aggregator looped on 30s `recv_fifo` timeouts forever
+once enough trainers went quiet near a trace's tail, never reaching its own
+`max_experiment_runtime_s` self-stop check (which only runs once recv_ends
+goes empty). See UNAVAILABILITY_DESIGN.md, Batch 4 finding 1.
+
+Mirrors the harness pattern in test_agg_start_ts_broadcast.py.
+"""
+
+from __future__ import annotations
+
+import types
+
+import pytest
+
+
+class _DistChannel:
+    """Records every dispatched payload/property, no real transport."""
+
+    def __init__(self, ends):
+        self._ends = {e: None for e in ends}
+        self.properties = {}
+        self.props = {}
+        self.sent = {}
+        self._selector = types.SimpleNamespace(selected_ends=set())
+
+    def await_join(self):
+        pass
+
+    def ends(self, state, task=None, **kw):
+        return list(self._ends.keys())
+
+    def dumps(self, msg):
+        return dict(msg)
+
+    def send_payload(self, end, payload):
+        self.sent[end] = payload
+
+    def set_end_property(self, end, key, value):
+        self.props.setdefault(end, {})[key] = value
+
+    def set_curr_unavailable_trainers(self, trainer_unavail_list=None):
+        self.unavail = list(trainer_unavail_list or [])
+
+
+def _stub_common(agg, channel, *, simulated, evict_spy, abandon_spy):
+    agg.simulated = simulated
+    agg.agg_start_time_ts = 1_700_000_000.0
+    agg._round = 3
+    agg.trainer_event_dict = None  # gate off: skip the oracular unavailable-list path
+    agg.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel)
+    agg._await_min_trainers = lambda ch: None
+    agg._update_weights = lambda: None
+    agg._inject_oracle_utilities = lambda ch, task: None
+    agg._avail_stamp_end_states = lambda ch: None
+    agg._avail_now = lambda: 0.0
+    agg._sim_abandon_stalled = abandon_spy
+    agg._sim_evict_unavail_inflight = evict_spy
+    agg.datasampler = types.SimpleNamespace(get_metadata=lambda r, e: {})
+    agg.weights = {}
+
+
+def _spies():
+    calls = {"evict": 0, "abandon": 0}
+
+    def evict_spy(ch):
+        calls["evict"] += 1
+
+    def abandon_spy(ch):
+        calls["abandon"] += 1
+
+    return calls, evict_spy, abandon_spy
+
+
+@pytest.fixture(autouse=True)
+def _identity_weights(monkeypatch):
+    import flame.mode.horizontal.syncfl.top_aggregator as syncfl_mod
+    import flame.mode.horizontal.oort.top_aggregator as oort_mod
+
+    monkeypatch.setattr(syncfl_mod, "weights_to_device", lambda w, d: w)
+    monkeypatch.setattr(oort_mod, "weights_to_device", lambda w, d: w)
+
+
+def _make_syncfl_agg(channel, *, simulated, evict_spy, abandon_spy):
+    from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator
+
+    class _Concrete(TopAggregator):
+        def check_and_sleep(self):
+            pass
+
+        def evaluate(self):
+            pass
+
+        def initialize(self):
+            pass
+
+        def load_data(self):
+            pass
+
+        def train(self):
+            pass
+
+    agg = _Concrete.__new__(_Concrete)
+    _stub_common(agg, channel, simulated=simulated, evict_spy=evict_spy, abandon_spy=abandon_spy)
+    agg.config = types.SimpleNamespace(
+        hyperparameters=types.SimpleNamespace(aggregation_goal=1)
+    )
+    return agg
+
+
+def _make_oort_agg(channel, *, simulated, evict_spy, abandon_spy):
+    from flame.mode.horizontal.oort.top_aggregator import TopAggregator
+
+    class _Concrete(TopAggregator):
+        def check_and_sleep(self):
+            pass
+
+        def evaluate(self):
+            pass
+
+        def initialize(self):
+            pass
+
+        def load_data(self):
+            pass
+
+        def train(self):
+            pass
+
+    agg = _Concrete.__new__(_Concrete)
+    _stub_common(agg, channel, simulated=simulated, evict_spy=evict_spy, abandon_spy=abandon_spy)
+    agg.config = types.SimpleNamespace(
+        selector=types.SimpleNamespace(kwargs={"aggr_num": 1}),
+        hyperparameters=types.SimpleNamespace(sim_inflight_residence=False),
+    )
+    return agg
+
+
+def _make_asyncfl_agg(channel, *, simulated, evict_spy, abandon_spy):
+    from flame.mode.horizontal.asyncfl.top_aggregator import TopAggregator
+    from flame.sim import VirtualClock
+
+    class _Concrete(TopAggregator):
+        def check_and_sleep(self):
+            pass
+
+        def evaluate(self):
+            pass
+
+        def initialize(self):
+            pass
+
+        def load_data(self):
+            pass
+
+        def train(self):
+            pass
+
+    agg = _Concrete.__new__(_Concrete)
+    _stub_common(agg, channel, simulated=simulated, evict_spy=evict_spy, abandon_spy=abandon_spy)
+    agg._vclock = VirtualClock()
+    agg._sim_staggered_redispatch = False
+    agg._sim_inflight_residence = False
+    agg._sim_free_slot_ts = __import__("collections").deque(maxlen=128)
+    agg._sim_last_commit_sct = {}
+    agg._sim_inflight_expected = {}
+    agg._sim_trainer_budget = {}
+    agg._sim_budget_min = 12.0
+    agg._sim_redispatch_gap_s = 0.0
+    agg._sim_cooldown_until = {}
+    agg._real_distribute_settle_s = 0.0
+    agg._track_trainer_version_duration_s = {}
+    agg.weights = {}
+    return agg
+
+
+class TestProactiveEvictBothModes:
+    """D.1 eviction runs regardless of mode; the sim-only 90s re-clock doesn't."""
+
+    def test_syncfl_real_mode_still_evicts(self):
+        ch = _DistChannel(["e1", "e2"])
+        calls, evict_spy, abandon_spy = _spies()
+        agg = _make_syncfl_agg(ch, simulated=False, evict_spy=evict_spy, abandon_spy=abandon_spy)
+        agg._distribute_weights("tag", "train")
+        assert calls["evict"] == 1
+        assert calls["abandon"] == 0
+
+    def test_syncfl_sim_mode_evicts_and_abandons(self):
+        from flame.sim import VirtualClock
+
+        ch = _DistChannel(["e1", "e2"])
+        calls, evict_spy, abandon_spy = _spies()
+        agg = _make_syncfl_agg(ch, simulated=True, evict_spy=evict_spy, abandon_spy=abandon_spy)
+        agg._vclock = VirtualClock()
+        agg._distribute_weights("tag", "train")
+        assert calls["evict"] == 1
+        assert calls["abandon"] == 1
+
+    def test_oort_real_mode_still_evicts(self):
+        ch = _DistChannel(["e1", "e2"])
+        calls, evict_spy, abandon_spy = _spies()
+        agg = _make_oort_agg(ch, simulated=False, evict_spy=evict_spy, abandon_spy=abandon_spy)
+        agg._distribute_weights("tag", "train")
+        assert calls["evict"] == 1
+        assert calls["abandon"] == 0
+
+    def test_oort_sim_mode_evicts_and_abandons(self):
+        from flame.sim import VirtualClock
+
+        ch = _DistChannel(["e1", "e2"])
+        calls, evict_spy, abandon_spy = _spies()
+        agg = _make_oort_agg(ch, simulated=True, evict_spy=evict_spy, abandon_spy=abandon_spy)
+        agg._vclock = VirtualClock()
+        agg._distribute_weights("tag", "train")
+        assert calls["evict"] == 1
+        assert calls["abandon"] == 1
+
+    def test_asyncfl_real_mode_still_evicts(self):
+        ch = _DistChannel(["e1", "e2"])
+        calls, evict_spy, abandon_spy = _spies()
+        agg = _make_asyncfl_agg(ch, simulated=False, evict_spy=evict_spy, abandon_spy=abandon_spy)
+        agg._distribute_weights("tag", "train")
+        assert calls["evict"] == 1
+        assert calls["abandon"] == 0
+
+    def test_asyncfl_sim_mode_evicts_and_abandons(self):
+        ch = _DistChannel(["e1", "e2"])
+        calls, evict_spy, abandon_spy = _spies()
+        agg = _make_asyncfl_agg(ch, simulated=True, evict_spy=evict_spy, abandon_spy=abandon_spy)
+        agg._distribute_weights("tag", "train")
+        assert calls["evict"] == 1
+        assert calls["abandon"] == 1
diff --git a/lib/python/tests/mode/test_send_gate_wait.py b/lib/python/tests/mode/test_send_gate_wait.py
new file mode 100644
index 000000000..c4c961ee0
--- /dev/null
+++ b/lib/python/tests/mode/test_send_gate_wait.py
@@ -0,0 +1,185 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Batch 3 T3.4: trainer-side [SEND_GATE] delay decomposition telemetry.
+
+`_send_weights`'s UN_AVL wait loop (syncfl/trainer.py) is the actual
+enforcement point of the real-mode send-time gate (T3.1a/T3.1b landed the
+mechanism; this task instruments it). Two new fields on the `task_send`
+event -- not `trainer_round` (task/train() emits trainer_round BEFORE
+put()/_send_weights runs, per the tasklet composition in `Trainer.compose`,
+so `_phase_times` merged there can never see this loop's timing for the
+same round; task_send already exists for exactly this ordering reason, see
+`build_task_send`'s own docstring re: wall_send_ts):
+  - `send_gate_sct`: the trainer's own trace-time-basis clock (`_sim_now()`)
+    sampled right before the gate check, real mode only, regardless of
+    whether the gate actually engages.
+  - `send_gate_wait_s`: wall-time actually spent blocked in the loop (0.0
+    when the gate never engaged), real mode only; always None in sim mode.
+"""
+
+import types
+
+import pytest
+
+from flame.config import TrainerAvailState
+
+
+class _FakeClock:
+    """Deterministic time.time()/time.sleep() so wait duration is exact."""
+
+    def __init__(self, start=1_000.0):
+        self.t = start
+
+    def time(self):
+        return self.t
+
+    def sleep(self, s):
+        self.t += s
+
+
+def _make_trainer():
+    from flame.mode.horizontal.syncfl.trainer import Trainer
+
+    class _Concrete(Trainer):
+        def check_and_sleep(self):
+            pass
+
+        def evaluate(self):
+            pass
+
+        def initialize(self):
+            pass
+
+        def load_data(self):
+            pass
+
+        def train(self):
+            pass
+
+    t = _Concrete.__new__(_Concrete)
+    t.trainer_id = "trainer-under-test"
+    t._round = 5
+    t._phase_times = {}
+    t.task_to_perform = "eval"  # skips the torch/cloudpickle weight-send path
+    t._stat_utility = 0.5
+    t._local_accuracy = 0.0
+    t._updates_returned_upto_round = 0
+    t.wait_until_next_avl = "True"
+    return t
+
+
+def _make_channel():
+    return types.SimpleNamespace(
+        await_join=lambda: None,
+        one_end=lambda state: "agg-end",
+        send=lambda end, msg: None,
+        _selector=types.SimpleNamespace(_cleanup_send_ends=lambda: None),
+    )
+
+
+@pytest.fixture
+def captured_events(monkeypatch):
+    """Capture every telemetry.emit() call made by syncfl/trainer.py."""
+    import flame.mode.horizontal.syncfl.trainer as trainer_mod
+
+    events: list = []
+    monkeypatch.setattr(trainer_mod.telemetry, "is_enabled", lambda: True)
+    monkeypatch.setattr(
+        trainer_mod.telemetry, "emit",
+        lambda ev, **fields: events.append((ev, fields)),
+    )
+    return events
+
+
+def _task_send_fields(events):
+    for ev, fields in events:
+        if ev == "task_send":
+            return fields
+    raise AssertionError("no task_send event emitted")
+
+
+class TestSendGateWaitRealMode:
+    def test_waits_and_stamps_observed_duration(self, monkeypatch, captured_events):
+        import flame.mode.horizontal.syncfl.trainer as trainer_mod
+
+        t = _make_trainer()
+        t.simulated = False
+        t.avl_state = TrainerAvailState.UN_AVL
+        t._sim_now = lambda: 500.0
+        t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel())
+
+        clock = _FakeClock()
+        calls = {"n": 0}
+
+        def _sleep(s):
+            clock.sleep(s)
+            calls["n"] += 1
+            if calls["n"] >= 3:
+                t.avl_state = TrainerAvailState.AVL_TRAIN
+
+        monkeypatch.setattr(trainer_mod.time, "time", clock.time)
+        monkeypatch.setattr(trainer_mod.time, "sleep", _sleep)
+
+        t._send_weights("tag")
+
+        fields = _task_send_fields(captured_events)
+        assert fields["send_gate_sct"] == 500.0
+        assert fields["send_gate_wait_s"] == pytest.approx(3.0)
+        assert calls["n"] == 3
+
+    def test_no_wait_when_already_available(self, monkeypatch, captured_events):
+        import flame.mode.horizontal.syncfl.trainer as trainer_mod
+
+        t = _make_trainer()
+        t.simulated = False
+        t.avl_state = TrainerAvailState.AVL_TRAIN
+        t._sim_now = lambda: 42.0
+        t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel())
+
+        def _sleep(_s):
+            raise AssertionError("sleep should never be called when already available")
+
+        monkeypatch.setattr(trainer_mod.time, "sleep", _sleep)
+
+        t._send_weights("tag")
+
+        fields = _task_send_fields(captured_events)
+        assert fields["send_gate_sct"] == 42.0
+        assert fields["send_gate_wait_s"] == 0.0
+
+    def test_missing_sim_now_leaves_sct_none(self, monkeypatch, captured_events):
+        """Defensive fallback: a base-class trainer with no _sim_now() override
+        (not every example wires one) must not raise -- sct is simply absent."""
+        t = _make_trainer()
+        t.simulated = False
+        t.avl_state = TrainerAvailState.AVL_TRAIN
+        assert not hasattr(t, "_sim_now")
+        t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel())
+
+        t._send_weights("tag")
+
+        fields = _task_send_fields(captured_events)
+        assert fields["send_gate_sct"] is None
+        assert fields["send_gate_wait_s"] == 0.0
+
+
+class TestSendGateWaitSimMode:
+    def test_sim_mode_never_stamps_gate_fields(self, monkeypatch, captured_events):
+        import flame.mode.horizontal.syncfl.trainer as trainer_mod
+
+        t = _make_trainer()
+        t.simulated = True
+        t.avl_state = TrainerAvailState.UN_AVL  # would gate in real mode; sim ignores it
+        t._sim_now = lambda: 999.0
+        t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel())
+
+        def _sleep(_s):
+            raise AssertionError("sim mode must never enter the wall-sleep gate loop")
+
+        monkeypatch.setattr(trainer_mod.time, "sleep", _sleep)
+
+        t._send_weights("tag")
+
+        fields = _task_send_fields(captured_events)
+        assert fields["send_gate_sct"] is None
+        assert fields["send_gate_wait_s"] is None
diff --git a/lib/python/tests/mode/test_sim_barrier.py b/lib/python/tests/mode/test_sim_barrier.py
index 7f309f57b..3020ed2d2 100644
--- a/lib/python/tests/mode/test_sim_barrier.py
+++ b/lib/python/tests/mode/test_sim_barrier.py
@@ -90,6 +90,12 @@ def _bare(cls):
     a = c.__new__(c)
     a._vclock = VirtualClock()
     a.simulated = True
+    # Gate-off availability state (production sets these in __init__ /
+    # _init_availability; __new__ bypasses both). The sim recv paths reference
+    # _sim_buffer directly; trainer_event_dict=None keeps the mixin helpers no-op.
+    a._sim_buffer = SimReorderBuffer()
+    a.trainer_event_dict = None
+    a.pending_withheld = {}
     return a
 
 
diff --git a/lib/python/tests/mode/test_sync_sim_ordering.py b/lib/python/tests/mode/test_sync_sim_ordering.py
index 295f00e7d..7b3583a8f 100644
--- a/lib/python/tests/mode/test_sync_sim_ordering.py
+++ b/lib/python/tests/mode/test_sync_sim_ordering.py
@@ -23,7 +23,7 @@
     PROP_CLIENT_TASK_TRAIN_DURATION,
     PROP_STAT_UTILITY,
 )
-from flame.sim import VirtualClock
+from flame.sim import VirtualClock, SimReorderBuffer
 
 
 class FakeSyncChannel:
@@ -89,6 +89,14 @@ def _make_agg():
     agg = _ConcreteSyncAgg.__new__(_ConcreteSyncAgg)
     agg._vclock = VirtualClock()
     agg.simulated = True
+    # Gate-off availability state. Production sets _sim_buffer in __init__ and the
+    # ledgers in _init_availability; __new__ bypasses both, so set them here.
+    # _sync_sim_recv_first_k references self._sim_buffer directly; trainer_event_dict
+    # =None + empty pending_withheld keep the ClientAvailability helpers no-op, so the
+    # sim-ordering logic is exercised in isolation (byte-identical to gate OFF).
+    agg._sim_buffer = SimReorderBuffer()
+    agg.trainer_event_dict = None
+    agg.pending_withheld = {}
     return agg
 
 
@@ -483,8 +491,17 @@ def do(self, weights, cache, total=0):
         class _SelCfg:
             kwargs = {"aggr_num": 10}
 
+        class _HP:
+            # Real-recv timeout block reads these (getattr-with-default in prod);
+            # max_experiment_runtime_s=None ⇒ recv timeout falls back to the stall
+            # default, no budget cap. (Was missing → AttributeError after the
+            # oort/syncfl real-recv timeout landed.)
+            trainer_recv_wall_timeout_s = 90.0
+            max_experiment_runtime_s = None
+
         class _Config:
             selector = _SelCfg()
+            hyperparameters = _HP()
 
         class _ConcreteOortAgg(OortTopAggregator):
             def check_and_sleep(self): pass
diff --git a/lib/python/tests/selector/test_oort_selector.py b/lib/python/tests/selector/test_oort_selector.py
index b659fa77f..5fe76243a 100644
--- a/lib/python/tests/selector/test_oort_selector.py
+++ b/lib/python/tests/selector/test_oort_selector.py
@@ -357,3 +357,50 @@ def test_cleanup_recvd_ends_clears_inflight(self, oort, make_ends):
         oort._cleanup_recvd_ends(make_ends(["a", "b", "c"]))
         assert oort.selected_ends == {"c"}
         assert oort.ordered_updates_recv_ends == []
+
+
+class TestChallenge13SendStateCleanup:
+    """The 'invalid prior selection' cleanup in _handle_send_state must key off
+    CONNECTED membership, not availability-eligibility (Challenge 13). An
+    in-flight trainer that merely went UN_AVL / wrong-task-type is absent from
+    the filtered eligible pool but still connected & computing — it must stay in
+    selected_ends. Only a genuinely disconnected end (gone from the channel) is
+    removed. Concurrency is sized so extra==0 and the method returns right after
+    cleanup, isolating the membership check."""
+
+    def test_unavailable_inflight_retained_when_connected_pool_passed(
+        self, async_oort, make_ends
+    ):
+        async_oort.requester = "agg"
+        async_oort.selected_ends = {"agg": {"t1", "t2"}}
+        connected = make_ends(["t1", "t2", "t3"])   # all still connected
+        eligible = {}                               # all currently unavailable
+        out = async_oort._handle_send_state(
+            ends=eligible, concurrency=2, channel_props={},
+            connected_ends=connected,
+        )
+        assert out == {}
+        # t1/t2 unavailable but connected → in-flight tracking preserved.
+        assert async_oort.selected_ends["agg"] == {"t1", "t2"}
+
+    def test_disconnected_inflight_removed(self, async_oort, make_ends):
+        async_oort.requester = "agg"
+        async_oort.selected_ends = {"agg": {"t1", "t2"}}
+        connected = make_ends(["t1"])               # t2 genuinely gone
+        async_oort._handle_send_state(
+            ends={}, concurrency=1, channel_props={},
+            connected_ends=connected,
+        )
+        assert async_oort.selected_ends["agg"] == {"t1"}
+
+    def test_fallback_to_eligible_when_no_connected_pool(
+        self, async_oort, make_ends
+    ):
+        # Backward-compat: with connected_ends omitted the check falls back to
+        # `ends` — the pre-fix behavior. Guards the default-arg contract.
+        async_oort.requester = "agg"
+        async_oort.selected_ends = {"agg": {"t1"}}
+        async_oort._handle_send_state(
+            ends=make_ends(["t1"]), concurrency=1, channel_props={},
+        )
+        assert async_oort.selected_ends["agg"] == {"t1"}
diff --git a/lib/python/tests/selector/test_send_timeout_frees_selected_ends.py b/lib/python/tests/selector/test_send_timeout_frees_selected_ends.py
new file mode 100644
index 000000000..e1d4b95c0
--- /dev/null
+++ b/lib/python/tests/selector/test_send_timeout_frees_selected_ends.py
@@ -0,0 +1,97 @@
+# Copyright 2026 Cisco Systems, Inc. and its affiliates
+# SPDX-License-Identifier: Apache-2.0
+"""Regression: the 90s SEND_TIMEOUT_WAIT_S abandon in async_oort.py/fedbuff.py
+must free the end from selected_ends, not just all_selected -- recv_ends
+derives from selected_ends, so leaving it there hangs recv_fifo forever
+(UNAVAILABILITY_DESIGN.md, Open A)."""
+
+import time
+
+import pytest
+
+
+class _StopAfterAbandon(Exception):
+    """Raised from a stubbed pacer() to inspect state right after the abandon
+    block runs, without driving async_oort's heavier downstream selection
+    (same technique as TestCoolingHoldsConcurrency in test_async_sim_ordering.py)."""
+
+
+def _boom():
+    raise _StopAfterAbandon()
+
+
+class TestAsyncOortSendTimeoutFreesSelectedEnds:
+    @staticmethod
+    def _stub_selector():
+        from flame.selector.async_oort import AsyncOortSelector
+
+        sel = AsyncOortSelector.__new__(AsyncOortSelector)
+        sel.requester = "agg"
+        sel.selected_ends = {"agg": {"stale"}}
+        sel.all_selected = {"stale": time.time() - 100}  # past 90s SEND_TIMEOUT_WAIT_S
+        sel.ordered_updates_recv_ends = []
+        sel.track_trainer_timeouts = {}
+        sel.pacer = _boom
+        return sel
+
+    def test_stale_end_leaves_both_all_selected_and_selected_ends(self, make_ends):
+        sel = self._stub_selector()
+        ends = make_ends(["stale", "fresh"])
+
+        with pytest.raises(_StopAfterAbandon):
+            sel._handle_send_state(
+                ends=ends,
+                concurrency=2,
+                channel_props={"round": 1},
+                trainer_unavail_list=[],
+                task_to_perform="train",
+                agg_version_state=(1, 0, 0),
+                trainer_version_states={},
+            )
+
+        assert "stale" not in sel.all_selected
+        assert "stale" not in sel.selected_ends["agg"]
+
+    def test_fresh_end_untouched(self, make_ends):
+        sel = self._stub_selector()
+        sel.all_selected["fresh"] = time.time()  # well within the 90s window
+        sel.selected_ends["agg"].add("fresh")
+        ends = make_ends(["stale", "fresh", "third"])
+
+        with pytest.raises(_StopAfterAbandon):
+            sel._handle_send_state(
+                ends=ends,
+                concurrency=3,  # 2 already selected -> extra=1, past the extra==0 short-circuit
+                channel_props={"round": 1},
+                trainer_unavail_list=[],
+                task_to_perform="train",
+                agg_version_state=(1, 0, 0),
+                trainer_version_states={},
+            )
+
+        assert "fresh" in sel.all_selected
+        assert "fresh" in sel.selected_ends["agg"]
+
+
+class TestFedBuffSendTimeoutFreesSelectedEnds:
+    @staticmethod
+    def _stub_selector():
+        from flame.selector.fedbuff import FedBuffSelector
+
+        sel = FedBuffSelector(c=2, aggGoal=1)
+        sel.requester = "agg"
+        sel.selected_ends = {"agg": {"stale"}}
+        sel.all_selected = {"stale": time.time() - 100}  # past 90s SEND_TIMEOUT_WAIT_S
+        return sel
+
+    def test_stale_end_leaves_both_all_selected_and_selected_ends(self, make_ends):
+        sel = self._stub_selector()
+        ends = make_ends(["stale", "fresh"])
+
+        # concurrency=1 with 1 already selected -> extra=0, fixed before the
+        # abandon loop runs, so the freed slot can't be immediately re-filled
+        # by the candidate loop below (a separate, correct RNG-dependent path).
+        sel._handle_send_state(ends=ends, concurrency=1, connected_ends=ends)
+
+        assert "stale" not in sel.all_selected
+        assert "stale" not in sel.selected_ends["agg"]
diff --git a/scripts/analysis/analyze_run.py b/scripts/analysis/analyze_run.py
index 811c3b574..6484d9e6e 100644
--- a/scripts/analysis/analyze_run.py
+++ b/scripts/analysis/analyze_run.py
@@ -46,13 +46,16 @@
         ),
     )
     from flame.telemetry.events import (  # noqa: E402
+        EVENT_AGG_BELIEF_CHANGE,
         EVENT_AGG_EVAL,
         EVENT_AGG_ROUND,
         EVENT_AVAIL_CHANGE,
         EVENT_SELECTION,
+        EVENT_TASK_SEND,
         EVENT_TRAINER_ROUND,
         EVENT_UTIL_DISPARITY,
         EVENT_UTILITY_BELIEF,
+        EVENT_WITHHELD_DELIVERY,
     )
 except Exception:  # pragma: no cover
     EVENT_SELECTION = "selection"
@@ -62,6 +65,40 @@
     EVENT_UTIL_DISPARITY = "util_disparity"
     EVENT_AVAIL_CHANGE = "avail_change"
     EVENT_UTILITY_BELIEF = "utility_belief"
+    EVENT_AGG_BELIEF_CHANGE = "agg_belief_change"
+    EVENT_TASK_SEND = "task_send"
+    EVENT_WITHHELD_DELIVERY = "withheld_delivery"
+
+# Batch 3 T3.2 (UNAVAILABILITY_DESIGN.md): the A6 trainer_trace_fidelity ground-
+# truth lookups live under the async_cifar10 example's parity checker package
+# (trace names / the trainer registry are example-specific), not in generic
+# flame/. Optional: absent for examples without an availability trace store.
+try:
+    sys.path.insert(
+        0,
+        os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            "..", "..", "lib", "python", "examples", "async_cifar10", "scripts",
+        ),
+    )
+    from parity.avail_state_series import (  # noqa: E402
+        build_observed_timeline_from_agg_belief,
+        build_observed_timeline_from_avail_change,
+        build_trainer_state_series,
+        selection_run_span,
+    )
+    from parity.checks import _fidelity_score  # noqa: E402
+    from parity.ground_truth import (  # noqa: E402
+        by_short_id,
+        expected_send_gate_wait,
+        load_ground_truth,
+        resolve_trace_name,
+        transitions_in_range,
+    )
+    from flame.availability.trace import state_at as _gt_state_at  # noqa: E402
+    _HAVE_GROUND_TRUTH = True
+except Exception:  # pragma: no cover
+    _HAVE_GROUND_TRUTH = False
 
 
 # Communication is reported in MEGABYTES. One model = MODEL_PARAM_COUNT fp32
@@ -1325,45 +1362,45 @@ def _participation_heatmap(records, d, stamp):
     rounds = sorted(set(trained) | set(evalsel))
     if not trainers or not rounds:
         return []
-    # Per-trainer availability per round (forward-filled from avail_change), so
-    # idle cells can distinguish "available, not picked" from "unavailable".
-    unavail = defaultdict(dict)  # trainer -> {round: True if UN_AVL}
-    ac = defaultdict(list)
-    for r in by_event(records, EVENT_AVAIL_CHANGE):
-        ac[str(r.get("end_id"))].append((int(r.get("round", 0)),
-                                         str(r.get("new_state", ""))))
-    for t, evs in ac.items():
-        evs.sort()
-        cur = None
-        for rd, st in evs:
-            cur = st
-            unavail[t][rd] = ("UN_AVL" in cur)
+    # Per-trainer availability per round — the aggregator's own belief
+    # (C.6.1/C.6.2), populated even in pure-oracular mode where the trainer-
+    # side avail_change log is empty. Forward-filled across rounds so idle
+    # cells can distinguish "available, not picked" from "unavailable".
+    avl_by_round = _avl_state_by_round(records)
     idx = {t: i for i, t in enumerate(trainers)}
     ridx = {r: j for j, r in enumerate(rounds)}
-    # 0 not-selected, 1 eval, 2 train, 3 unavailable (not selected),
-    # 4 selected-but-unavailable. Availability forward-filled across rounds.
+    # 0 not-selected (AVL_TRAIN idle), 1 eval, 2 train, 3 unavailable (not
+    # selected), 4 selected-but-unavailable (stale dispatch), 5 idle during
+    # AVL_EVAL (3-state extension — was binary unavailable/available).
     m = np.zeros((len(trainers), len(rounds)))
     for t in trainers:
-        last_un = False
+        last_state = "AVL_TRAIN"
+        rs = avl_by_round.get(t, {})
         for r in rounds:
-            if r in unavail.get(t, {}):
-                last_un = unavail[t][r]
-            sel = (t in evalsel.get(r, set())) or (t in trained.get(r, set()))
+            if r in rs:
+                last_state = rs[r]
+            is_unavail = "UN_AVL" in last_state
+            is_eval_idle = "AVL_EVAL" in last_state
             if t in trained.get(r, set()):
-                v = 4 if last_un else 2
+                v = 4 if is_unavail else 2
             elif t in evalsel.get(r, set()):
-                v = 4 if last_un else 1
+                v = 4 if is_unavail else 1
+            elif is_unavail:
+                v = 3
+            elif is_eval_idle:
+                v = 5
             else:
-                v = 3 if last_un else 0
+                v = 0
             m[idx[t], ridx[r]] = v
     yl = [t[-3:] for t in trainers] if len(trainers) <= 40 else None
     p = ph.heatmap(m, "round", "trainer", "Participation per trainer x round", d,
                    "participation_heatmap.pdf", stamp=stamp, yticklabels=yl,
-                   discrete=[(0, "not selected", "#ededed"),
+                   discrete=[(0, "not selected (AVL_TRAIN idle)", "#ededed"),
                              (1, "eval", "#3182bd"),
                              (2, "train", "#31a354"),
                              (3, "unavailable", "#fdae6b"),
-                             (4, "selected but unavail", "#e6550d")])
+                             (4, "selected but unavail", "#e6550d"),
+                             (5, "idle (AVL_EVAL)", "#9e9ac8")])
     return [p] if p else []
 
 
@@ -1389,15 +1426,14 @@ def _state_fraction_plots(records, d, stamp):
         if s.get("task") == "eval":
             for c in (s.get("chosen") or []):
                 evalsel[int(s.get("round", 0))].add(str(c))
-    # availability forward-fill: track the full state string so idle can be split
-    # into idle_train (AVL_TRAIN) vs idle_eval (AVL_EVAL). UN_AVL = unavailable.
-    ac = defaultdict(list)
-    for r in by_event(records, EVENT_AVAIL_CHANGE):
-        ac[str(r.get("end_id"))].append((int(r.get("round", 0)),
-                                         str(r.get("new_state", ""))))
+    # availability — the aggregator's own belief (C.6.1/C.6.2), populated even
+    # in pure-oracular mode where the trainer-side avail_change log is empty.
+    # Forward-fill: track the full state string so idle can be split into
+    # idle_train (AVL_TRAIN) vs idle_eval (AVL_EVAL). UN_AVL = unavailable.
+    avl_by_round = _avl_state_by_round(records)
     trainers = sorted({t for s in trained.values() for t in s}
                       | {t for s in evalsel.values() for t in s}
-                      | set(ac))
+                      | set(avl_by_round))
     rounds = sorted(set(trained) | set(evalsel))
     rounds = [r for r in rounds if r >= 1]
     if not trainers or not rounds:
@@ -1407,8 +1443,8 @@ def _state_fraction_plots(records, d, stamp):
     counts = {t: {c: 0 for c in cats} for t in trainers}
     avail_count = {t: 0 for t in trainers}
     for t in trainers:
-        evs = sorted(ac.get(t, []))
-        ei, state = 0, ""
+        evs = sorted(avl_by_round.get(t, {}).items())
+        ei, state = 0, "AVL_TRAIN"
         for r in rounds:
             while ei < len(evs) and evs[ei][0] <= r:
                 state = evs[ei][1]; ei += 1
@@ -2139,65 +2175,127 @@ def _cum(vals):
 # ==========================================================================
 
 
+def _avl_state_by_round(records) -> dict:
+    """{end_id: {round: avl_state}} — the AGGREGATOR's belief (C.6.1/C.6.2).
+
+    Sourced from `per_trainer[end_id]["avl_state"]` on every `selection` event
+    (train AND eval), which `emit_selection` stamps for the FULL candidate pool
+    (not just eligible/chosen). Replaces the old EVENT_AVAIL_CHANGE source,
+    which is the TRAINER's self-reported transition log — empty in v1's
+    pure-oracular mode (`client_notify` OFF) where the trainer never emits it,
+    leaving every consumer below permanently blind. The aggregator's belief is
+    populated in every mode (oracular or not), so this is the one source that
+    actually lights up under the v1 availability gate.
+    """
+    by_round: dict = defaultdict(dict)
+    for s in sorted(by_event(records, EVENT_SELECTION),
+                    key=lambda e: (e.get("round", 0), e.get("ts", 0.0))):
+        rd = int(s.get("round", 0))
+        for end_id, info in (s.get("per_trainer") or {}).items():
+            state = info.get("avl_state")
+            if state and state != "UNKNOWN":
+                by_round[str(end_id)][rd] = state
+    return dict(by_round)
+
+
 def availability_plots(records, out, stamp, tdir):
     d = _sub(out, "availability"); saved = []
     sel = by_event(records, EVENT_SELECTION)
-    ac = by_event(records, EVENT_AVAIL_CHANGE)
-
-    # 1) candidates → eligible → chosen funnel (binned over progress_key —
-    # data_id/iteration-level for fwdllm-family selection events that carry
-    # them, plain round otherwise; see progress_key()'s docstring). Always
-    # meaningful: shows where the population is lost between availability and pick.
-    fx, cand, elig, chos = [], [], [], []
+    avl_by_round = _avl_state_by_round(records)
+
+    # 1) candidates → (AVL_TRAIN/AVL_EVAL/UN_AVL composition) → eligible →
+    # chosen funnel (binned over progress_key — data_id/iteration-level for
+    # fwdllm-family selection events that carry them, plain round otherwise;
+    # see progress_key()'s docstring. train+eval both included — avail_
+    # composition is stamped on every selection event regardless of task, so
+    # this no longer silently drops the eval pool).
+    fx, cand, n_train, n_eval, n_unavail, elig, chos = [], [], [], [], [], [], []
     for s in sel:
-        if s.get("task", "train") != "train":
-            continue
         if int(s.get("round", 0)) < 1:  # exclude pre-training warmup (raw round)
             continue
-        nc, ne, nch = s.get("num_candidates"), s.get("num_eligible"), s.get("num_chosen")
+        nc = s.get("num_candidates")
         if nc is None:
             continue
-        fx.append(progress_key(s)); cand.append(nc)
+        comp = s.get("avail_composition") or {}
+        fx.append(progress_key(s))
+        cand.append(nc)
+        n_train.append(comp.get("AVL_TRAIN", 0))
+        n_eval.append(comp.get("AVL_EVAL", 0))
+        n_unavail.append(comp.get("UN_AVL", 0))
+        ne, nch = s.get("num_eligible"), s.get("num_chosen")
         elig.append(ne if ne is not None else 0)
         chos.append(nch if nch is not None else 0)
     if fx:
         p = ph.binned_line(
-            {"candidates": (fx, cand), "eligible": (fx, elig), "chosen": (fx, chos)},
+            {"candidates": (fx, cand), "AVL_TRAIN": (fx, n_train),
+             "AVL_EVAL": (fx, n_eval), "UN_AVL": (fx, n_unavail),
+             "eligible": (fx, elig), "chosen": (fx, chos)},
             PROGRESS_AXIS_LABEL, "trainer count",
-            "Availability→selection funnel (candidates→eligible→chosen, mean/bin)",
+            "Availability→selection funnel (candidates→composition→eligible"
+            "→chosen, train+eval, mean/bin)",
             d, "selection_funnel_over_rounds.pdf", stamp=stamp, nbins=150, reducer="mean")
         if p: saved.append(p)
 
-    # Determine if availability is DYNAMIC. syn_0 emits one AVL_TRAIN per trainer
-    # at startup and never changes → duty-cycle / churn plots are degenerate.
-    by_trainer = defaultdict(list)
-    states_seen = set()
-    for r in ac:
-        by_trainer[str(r.get("end_id"))].append((int(r.get("round", 0)),
-                                                  str(r.get("new_state", ""))))
-        states_seen.add(str(r.get("new_state", "")))
+    # Determine if availability is DYNAMIC. syn_0 reports one state (AVL_TRAIN)
+    # for every trainer for the whole run → duty-cycle / churn plots are
+    # degenerate. (Distinct-state count, not sample count — avl_by_round
+    # samples every round densely, unlike the old transition-only log.)
+    states_seen = {s for rs in avl_by_round.values() for s in rs.values()}
     has_unavail = any("UN_AVL" in s for s in states_seen)
-    dynamic = has_unavail or any(len(v) > 1 for v in by_trainer.values())
+    dynamic = has_unavail or any(
+        len(set(rs.values())) > 1 for rs in avl_by_round.values()
+    )
     if not dynamic:
         p = ph.no_data_plot(
             "Availability is static (no UN_AVL transitions)",
             d, "availability_dynamics.pdf", stamp=stamp,
-            note=f"{len(by_trainer)} trainers, states={sorted(states_seen)} — "
+            note=f"{len(avl_by_round)} trainers, states={sorted(states_seen)} — "
                  f"duty-cycle/churn need a dynamic trace (non-syn_0)")
         if p: saved.append(p)
         return saved
 
-    # 2) per-trainer duty cycle (fraction of the run available). Forward-fill the
-    # state across the round span; available = not UN_AVL.
+    by_trainer = {t: sorted(rs.items()) for t, rs in avl_by_round.items()}
+
+    # 2) population 3-state fraction over rounds — the plot the dynamic branch
+    # previously never produced at all (only the static no_data_plot branch
+    # wrote this filename; the doc's "always missing in the dynamic case" bug).
     rounds = sorted({rd for evs in by_trainer.values() for rd, _ in evs})
     rmax = max(rounds) if rounds else 0
+    dyn_x, dyn_train, dyn_eval, dyn_unavail = [], [], [], []
+    last_state = {t: "AVL_TRAIN" for t in by_trainer}
+    by_trainer_iter = {t: iter(evs) for t, evs in by_trainer.items()}
+    next_evt = {t: next(it, None) for t, it in by_trainer_iter.items()}
+    for r in rounds:
+        for t, it in by_trainer_iter.items():
+            while next_evt[t] is not None and next_evt[t][0] <= r:
+                last_state[t] = next_evt[t][1]
+                next_evt[t] = next(it, None)
+        n = len(last_state) or 1
+        dyn_x.append(r)
+        dyn_train.append(sum(1 for s in last_state.values() if s == "AVL_TRAIN") / n)
+        dyn_eval.append(sum(1 for s in last_state.values() if s == "AVL_EVAL") / n)
+        dyn_unavail.append(sum(1 for s in last_state.values() if "UN_AVL" in s) / n)
+    if dyn_x:
+        p = ph.binned_line(
+            {"AVL_TRAIN": (dyn_x, dyn_train), "AVL_EVAL": (dyn_x, dyn_eval),
+             "UN_AVL": (dyn_x, dyn_unavail)},
+            "round", "fraction of population",
+            "Population 3-state availability over the run", d,
+            "availability_dynamics.pdf", stamp=stamp, nbins=150, reducer="mean")
+        if p: saved.append(p)
+
+    # 3) per-trainer duty cycle (fraction of the run available). Forward-fill
+    # the state across the round span (telescoping sum — exact whether the
+    # input is sparse transitions or this dense per-round sampling);
+    # available = not UN_AVL.
     duty = []
     churn_by_round = defaultdict(int)
     for t, evs in by_trainer.items():
-        evs = sorted(evs)
-        for rd, _ in evs:
-            churn_by_round[rd] += 1
-        # integrate availability over [0, rmax]
+        prev_state = None
+        for rd, st in evs:
+            if prev_state is not None and st != prev_state:
+                churn_by_round[rd] += 1
+            prev_state = st
         avail_rounds, cur_r, cur_un = 0, 0, False
         for rd, st in evs:
             if not cur_un:
@@ -2211,13 +2309,300 @@ def availability_plots(records, out, stamp, tdir):
                     "duty_cycle_cdf.pdf", stamp=stamp)
     if p: saved.append(p)
 
-    # 3) availability churn rate over rounds (avail_change events / round-bin)
+    # 4) availability churn rate over rounds (actual state TRANSITIONS per
+    # round-bin, not raw sample density).
     cr = sorted(churn_by_round)
-    p = ph.binned_line({"avail_change events": (cr, [churn_by_round[r] for r in cr])},
-                       "round", "transitions", "Availability churn rate (events/bin)",
+    p = ph.binned_line({"avl_state transitions": (cr, [churn_by_round[r] for r in cr])},
+                       "round", "transitions", "Availability churn rate (transitions/bin)",
                        d, "availability_churn_over_rounds.pdf", stamp=stamp,
                        nbins=150, reducer="sum")
     if p: saved.append(p)
+
+    # 5) Per-trainer state fraction sorted bar — the visual companion to A4dur.
+    # Sorted by UN_AVL fraction (most unavailable first); uses the same dense
+    # per-round `by_trainer` observations as the duty-cycle CDF above, not the
+    # old sparse EVENT_AVAIL_CHANGE transition log.
+    trainer_fracs = []
+    for t, evs in by_trainer.items():
+        states = [st for _, st in evs]
+        n = len(states) or 1
+        tr_frac = sum(1 for s in states if s == "AVL_TRAIN") / n
+        ev_frac = sum(1 for s in states if s == "AVL_EVAL") / n
+        un_frac = sum(1 for s in states if "UN_AVL" in s) / n
+        trainer_fracs.append((t, tr_frac, ev_frac, un_frac))
+    trainer_fracs.sort(key=lambda x: x[3], reverse=True)
+    if trainer_fracs:
+        cats = [str(i + 1) for i in range(len(trainer_fracs))]
+        segs = {
+            "UN_AVL":    [x[3] for x in trainer_fracs],
+            "AVL_EVAL":  [x[2] for x in trainer_fracs],
+            "AVL_TRAIN": [x[1] for x in trainer_fracs],
+        }
+        colors = {"AVL_TRAIN": "#2196F3", "AVL_EVAL": "#4CAF50", "UN_AVL": "#F44336"}
+        p = ph.stacked_bar(
+            cats, segs, "fraction of run",
+            f"Per-trainer state fractions sorted by UN_AVL (n={len(trainer_fracs)}; "
+            f"visual companion to A4dur)",
+            d, "trainer_state_fractions_sorted.pdf",
+            stamp=stamp, horizontal=True, colors=colors,
+        )
+        if p: saved.append(p)
+    return saved
+
+
+def _gt_segments(trace, t_end) -> list:
+    """[(t_start, t_end, state), ...] ground-truth segments over [0, t_end]."""
+    pts = [(0.0, _gt_state_at(trace, 0.0).value)]
+    pts.extend(transitions_in_range(trace, 0.0, t_end))
+    segs = [(a, b, s) for (a, s), (b, _) in zip(pts, pts[1:])]
+    if pts:
+        segs.append((pts[-1][0], t_end, pts[-1][1]))
+    return segs
+
+
+def _obs_segments(pts, t_end) -> list:
+    """[(t_start, t_end, state), ...] observed segments from a forward-fill series."""
+    segs = [(a, b, s) for (a, s), (b, _) in zip(pts, pts[1:])]
+    if pts:
+        segs.append((pts[-1][0], t_end, pts[-1][1]))
+    return segs
+
+
+def trace_fidelity_plots(records, out, stamp, tdir):
+    """A6 trainer_trace_fidelity deep-dive: each trainer's own OBSERVED
+    availability timeline (from its avail_change telemetry) plotted directly
+    against the raw ground-truth trace file -- absolute, single-mode, no
+    real-vs-sim compare (that's availability_plots()/A5 above). Would have
+    made the real-mode-trainers-never-saw-the-trace bug (T3.1a) visually
+    obvious: every real trainer's band would be a flat AVL_TRAIN bar under a
+    ground-truth band that clearly transitions.
+    """
+    d = _sub(out, "availability")
+    if not _HAVE_GROUND_TRUTH:
+        return []
+    run_dir = os.path.dirname(os.path.abspath(tdir))
+    trace_name = resolve_trace_name(run_dir)
+    ground_truth = load_ground_truth(trace_name)
+    if not ground_truth:
+        return []
+    gt_by_short = by_short_id(ground_truth)
+
+    sel = by_event(records, EVENT_SELECTION)
+    mode = "sim" if any(s.get("vclock_now") is not None for s in sel) else "real"
+    span = selection_run_span(sel, mode)
+    if span <= 0:
+        return []
+
+    by_end: dict = defaultdict(list)
+    for r in by_event(records, EVENT_AVAIL_CHANGE):
+        end_id = r.get("end_id")
+        if end_id is not None:
+            by_end[str(end_id)].append(r)
+
+    errs, gt_segs_by_short, obs_segs_by_short = {}, {}, {}
+    for end_id, evs in by_end.items():
+        short_id = end_id[-4:]
+        gt = gt_by_short.get(short_id)
+        if gt is None:
+            continue
+        raw_obs = build_observed_timeline_from_avail_change(evs)
+        scored = _fidelity_score(raw_obs, gt, span, seed_state="AVL_TRAIN")
+        if scored is None:
+            continue
+        errs[short_id] = scored[0]
+        gt_segs_by_short[short_id] = _gt_segments(gt, span)
+        obs_segs_by_short[short_id] = _obs_segments(raw_obs, span)
+
+    saved = []
+    if not errs:
+        return saved
+
+    # (b) fidelity-error distribution — outliers are exactly the trainers this
+    # rung exists to catch (item 20 would show as *every* real trainer here).
+    p = ph.cdf_plot(
+        list(errs.values()), "trace fidelity error (TVD, lower=better)",
+        f"A6 trainer_trace_fidelity error CDF ({mode}, n={len(errs)})",
+        d, f"trace_fidelity_error_cdf_{mode}.pdf", stamp=stamp)
+    if p: saved.append(p)
+
+    # (a) per-trainer timeline overlay, worst-fidelity-first, capped so the
+    # figure stays legible — outlier trainers are the ones actually shown.
+    worst = sorted(errs.items(), key=lambda kv: -kv[1])[:12]
+    rows = [
+        (f"{short_id} (err={err:.3f})", gt_segs_by_short[short_id], obs_segs_by_short[short_id])
+        for short_id, err in worst
+    ]
+    p = ph.state_band_timeline(
+        rows, span,
+        f"A6 trainer_trace_fidelity: worst {len(rows)} trainers, "
+        f"ground-truth vs observed ({mode})",
+        d, f"trace_fidelity_timeline_{mode}.pdf", stamp=stamp)
+    if p: saved.append(p)
+    return saved
+
+
+def agg_belief_fidelity_plots(records, out, stamp, tdir):
+    """A7 agg_belief_fidelity deep-dive (Batch 3 T3.3): the AGGREGATOR's own
+    belief about each trainer's availability plotted against the raw
+    ground-truth trace, independently per checkpoint --
+    **selection** (reuses the existing per-candidate avl_state already
+    stamped every selection cycle) and **commit** (new agg_belief_change
+    telemetry, from _record_commit_belief). Companion to trace_fidelity_plots
+    (A6, the TRAINER's own self-report) -- this is the aggregator's side of
+    the same absolute (vs. ground truth, not real-vs-sim) question.
+    """
+    d = _sub(out, "availability")
+    if not _HAVE_GROUND_TRUTH:
+        return []
+    run_dir = os.path.dirname(os.path.abspath(tdir))
+    trace_name = resolve_trace_name(run_dir)
+    ground_truth = load_ground_truth(trace_name)
+    if not ground_truth:
+        return []
+    gt_by_short = by_short_id(ground_truth)
+
+    sel = by_event(records, EVENT_SELECTION)
+    mode = "sim" if any(s.get("vclock_now") is not None for s in sel) else "real"
+    span = selection_run_span(sel, mode)
+    if span <= 0:
+        return []
+
+    def _score_all(series_by_end, seed_state):
+        errs, gt_segs, obs_segs = {}, {}, {}
+        for end_id, raw_obs in series_by_end.items():
+            short_id = str(end_id)[-4:]
+            gt = gt_by_short.get(short_id)
+            if gt is None:
+                continue
+            scored = _fidelity_score(raw_obs, gt, span, seed_state=seed_state)
+            if scored is None:
+                continue
+            errs[short_id] = scored[0]
+            gt_segs[short_id] = _gt_segments(gt, span)
+            obs_segs[short_id] = _obs_segments(raw_obs, span)
+        return errs, gt_segs, obs_segs
+
+    sel_series = build_trainer_state_series(sel, mode=mode)
+    sel_scores = _score_all(sel_series, seed_state="AVL_TRAIN")
+
+    commit_by_end: dict = defaultdict(list)
+    for r in by_event(records, EVENT_AGG_BELIEF_CHANGE):
+        if r.get("checkpoint") != "commit":
+            continue
+        end_id = r.get("end_id")
+        if end_id is not None:
+            commit_by_end[str(end_id)].append(r)
+    commit_series = {
+        end_id: build_observed_timeline_from_agg_belief(evs)
+        for end_id, evs in commit_by_end.items()
+    }
+    commit_scores = _score_all(commit_series, seed_state=None)
+
+    saved = []
+    for checkpoint, (errs, gt_segs, obs_segs) in (
+        ("selection", sel_scores), ("commit", commit_scores),
+    ):
+        if not errs:
+            continue
+        p = ph.cdf_plot(
+            list(errs.values()), "belief fidelity error (TVD, lower=better)",
+            f"A7 agg_belief_fidelity error CDF ({mode}, {checkpoint}, n={len(errs)})",
+            d, f"belief_fidelity_error_cdf_{mode}_{checkpoint}.pdf", stamp=stamp)
+        if p: saved.append(p)
+
+        worst = sorted(errs.items(), key=lambda kv: -kv[1])[:12]
+        rows = [
+            (f"{short_id} (err={err:.3f})", gt_segs[short_id], obs_segs[short_id])
+            for short_id, err in worst
+        ]
+        p = ph.state_band_timeline(
+            rows, span,
+            f"A7 agg_belief_fidelity: worst {len(rows)} trainers, "
+            f"belief vs ground-truth ({mode}, {checkpoint})",
+            d, f"belief_fidelity_timeline_{mode}_{checkpoint}.pdf", stamp=stamp)
+        if p: saved.append(p)
+    return saved
+
+
+def send_gate_wait_plots(records, out, stamp, tdir):
+    """A8 send_gate_wait_fidelity deep-dive (Batch 3 T3.4): real-mode
+    [SEND_GATE] wait duration vs. what the raw ground-truth trace says it
+    should have been. Reads task_send (not trainer_round) -- the wait loop
+    runs strictly after trainer_round is emitted for the same round (train()
+    then put()/_send_weights, per the tasklet composition), so task_send is
+    the event that can actually carry it, same reason wall_send_ts lives
+    there instead of trainer_round.
+    """
+    d = _sub(out, "availability")
+    if not _HAVE_GROUND_TRUTH:
+        return []
+    run_dir = os.path.dirname(os.path.abspath(tdir))
+    trace_name = resolve_trace_name(run_dir)
+    ground_truth = load_ground_truth(trace_name)
+    if not ground_truth:
+        return []
+    gt_by_short = by_short_id(ground_truth)
+
+    observed, expected = [], []
+    for r in by_event(records, EVENT_TASK_SEND):
+        obs = r.get("send_gate_wait_s")
+        sct = r.get("send_gate_sct")
+        end_id = r.get("end_id")
+        if obs is None or sct is None or end_id is None:
+            continue
+        gt = gt_by_short.get(str(end_id)[-4:])
+        if gt is None:
+            continue
+        exp = expected_send_gate_wait(gt, float(sct))
+        if exp is None:
+            continue
+        observed.append(float(obs))
+        expected.append(exp)
+
+    saved = []
+    if not observed:
+        return saved
+
+    p = ph.cdf_plot(
+        observed, "send_gate_wait_s (observed)",
+        f"A8 send_gate_wait_s distribution (real, n={len(observed)})",
+        d, "send_gate_wait_cdf.pdf", stamp=stamp)
+    if p: saved.append(p)
+
+    p = ph.scatter_diag(
+        expected, observed,
+        "ground-truth-expected wait (s)", "observed send_gate_wait_s (s)",
+        f"A8 send_gate_wait_fidelity: observed vs expected (n={len(observed)})",
+        d, "send_gate_wait_scatter.pdf", stamp=stamp)
+    if p: saved.append(p)
+    return saved
+
+
+def commit_promptness_plots(records, out, stamp, tdir):
+    """K11 commit_promptness deep-dive (Batch 3 T3.5): distribution of
+    "commit slack" (actual_commit_ts - delivery_ts) across every withheld-
+    then-delivered update. Should cluster near 0; a heavy right tail flags a
+    promptness/scheduling bug (e.g. coarse reinjection polling); any mass left
+    of the marked zero-line is a hard correctness bug (a commit landing
+    before it was legally available). Sim-only (real emits no
+    withheld_delivery telemetry at all — a different, trainer-side gate).
+    """
+    d = _sub(out, "availability")
+    slacks = []
+    for r in by_event(records, EVENT_WITHHELD_DELIVERY):
+        act, dts = r.get("actual_commit_ts"), r.get("delivery_ts")
+        if act is None or dts is None:
+            continue
+        slacks.append(float(act) - float(dts))
+
+    saved = []
+    if not slacks:
+        return saved
+    p = ph.hist_plot(
+        slacks, "commit_slack_s (actual_commit_ts - delivery_ts)",
+        f"K11 commit_promptness: commit slack (sim, n={len(slacks)})",
+        d, "commit_slack_hist.pdf", stamp=stamp, vline=0.0)
+    if p: saved.append(p)
     return saved
 
 
@@ -2450,7 +2835,9 @@ def analyze(telemetry_dir, out_dir=None):
     saved = []
     for fn in (perf_plots, sanity_plots, selection_plots, insights_plots,
                system_plots, sim_speedup_plots, mqtt_delivery_plots,
-               availability_plots, selection_why_plots, aggregation_plots):
+               availability_plots, trace_fidelity_plots, agg_belief_fidelity_plots,
+               send_gate_wait_plots, commit_promptness_plots,
+               selection_why_plots, aggregation_plots):
         try:
             saved.extend(fn(records, out_dir, stamp, telemetry_dir))
         except Exception as e:
diff --git a/scripts/analysis/plot_helpers.py b/scripts/analysis/plot_helpers.py
index 0f165d88a..b3bc9bdef 100644
--- a/scripts/analysis/plot_helpers.py
+++ b/scripts/analysis/plot_helpers.py
@@ -596,6 +596,42 @@ def stacked_bar(categories, segments, y_label, title, out_dir, file_name, stamp=
     return _save(fig, out_dir, file_name, stamp)
 
 
+_TRACE_STATE_COLORS = {"AVL_TRAIN": "#2196F3", "AVL_EVAL": "#4CAF50", "UN_AVL": "#F44336"}
+
+
+def state_band_timeline(rows, x_max, title, out_dir, file_name, stamp=None):
+    """Per-trainer ground-truth-vs-observed availability state overlay
+    (Batch 3 T3.2 / A6 trainer_trace_fidelity).
+
+    ``rows``: [(trainer_label, gt_segments, obs_segments), ...], already
+    ordered/truncated by the caller (e.g. worst-fidelity-first, capped to a
+    legible row count). Each ``*_segments`` is [(t_start, t_end, state), ...].
+    Two horizontal bands per trainer — ground truth above, observed below —
+    colored by state, so a fidelity gap is visible as a color mismatch between
+    the two bands at the same x position rather than a number in a table.
+    """
+    if not rows:
+        return no_data_plot(title, out_dir, file_name, stamp)
+    fig, ax = plt.subplots(figsize=(7.5, max(1.5, 0.55 * len(rows) + 0.8)))
+    for i, (label, gt_segs, obs_segs) in enumerate(rows):
+        y0 = i * 1.1
+        for segs, y in ((gt_segs, y0 + 0.5), (obs_segs, y0)):
+            bars = [(a, b - a) for a, b, _ in segs if b > a]
+            colors = [_TRACE_STATE_COLORS.get(s, "0.6") for a, b, s in segs if b > a]
+            if bars:
+                ax.broken_barh(bars, (y, 0.42), facecolors=colors)
+    ax.set_yticks([i * 1.1 + 0.5 for i in range(len(rows))])
+    ax.set_yticklabels([lab for lab, _, _ in rows], fontsize=8)
+    ax.set_ylim(-0.15, len(rows) * 1.1)
+    ax.set_xlim(0, x_max)
+    ax.set_xlabel("trace time (s) — top band=ground truth, bottom band=observed")
+    ax.set_title(title)
+    handles = [plt.Rectangle((0, 0), 1, 1, color=c) for c in _TRACE_STATE_COLORS.values()]
+    ax.legend(handles, list(_TRACE_STATE_COLORS.keys()), loc="upper right",
+             fontsize=8, ncol=3)
+    return _save(fig, out_dir, file_name, stamp)
+
+
 def bar_plot(categories, values, y_label, title, out_dir, file_name, stamp=None):
     if len(categories) == 0:
         return None