@@ -26,7 +26,7 @@ The protocol uses no words or alphabet, but four meaning-free local symbols. For
 See [`docs/results-ecp6.md`](docs/results-ecp6.md) for the conclusion, [`docs/protocol-specification-ecp6.md`](docs/protocol-specification-ecp6.md) for the wire format and [`evidence/ecp6/report.md`](evidence/ecp6/report.md) for the compact confirmatory evidence.
 
 ECP-7 development now tests how much of that result depends on the explicit
-one-factor-per-slot architecture. Its first twenty-three sealed batches are valid
+one-factor-per-slot architecture. Its first twenty-four sealed batches are valid
 development results but none passes the full gate. Batch 15 established the
 strong position-aware base: at 30,000 optimization steps it reaches 83.46% train
 exactness, 82.59% validation and 83.37% translator validation while using
@@ -48,7 +48,10 @@ confirmatory test remains sealed. Batch 22 routed shared-error replay only into
 senders; this reduced shared errors but increased cross-link fragmentation and
 regressed validation to 83.51%. Batch 23 restored joint replay after the
 sender-only warmup. Validation remained 83.50%; total fragmented errors fell,
-but the shared-error pool immediately regrew and injectivity still failed. See
+but the shared-error pool immediately regrew and injectivity still failed.
+Batch 24 made the second phase receiver-only. It established new-best means of
+84.69% train, 84.48% validation and 84.55% translator validation, but the
+worst-link and injectivity gates still failed. See
 [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md).
 
 ## Build on this work
@@ -112,6 +115,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`config/ecp7-b21-development.yaml`](config/ecp7-b21-development.yaml) — Batch 20 replay restricted to meanings failed by all 16 population links.
 - [`config/ecp7-b22-development.yaml`](config/ecp7-b22-development.yaml) — Batch 21 replay with receiver-parameter gradients disabled only on the replay branch.
 - [`config/ecp7-b23-development.yaml`](config/ecp7-b23-development.yaml) — Batch 22 sender-only replay through step 20,000 followed by restored joint replay gradients.
+- [`config/ecp7-b24-development.yaml`](config/ecp7-b24-development.yaml) — Batch 23 routing with sender messages detached for receiver-only replay after step 20,000.
 - [`config/ecp7-positive-control-development.yaml`](config/ecp7-positive-control-development.yaml) — ECP-6 positive control on the ECP-7 split.
 - [`config/ecp0.yaml`](config/ecp0.yaml) — machine-readable configuration from step 1.
 - [`config/ecp1.yaml`](config/ecp1.yaml) — frozen configuration of the population trial.
 
@@ -0,0 +1,13 @@
+extends: ecp7-b23-development.yaml
+
+experiment:
+  title: ECP-7 receiver-only hard-replay catch-up
+  arm: receiver_only_hard_replay_catchup
+  objective: >-
+    Test whether a sender-only replay warmup followed by receiver-only replay
+    can preserve separated sender codes while allowing receivers to catch up
+    without joint replay coadaptation.
+
+training:
+  global_hard_meaning_replay:
+    disable_sender_message_gradients_after_step: 20000
@@ -41,7 +41,7 @@ python3.12 -m venv .venv
 .venv/bin/ecp6 --config config/ecp6.yaml validate
 ```
 
-Expected baseline: 117 passing tests and split sizes `14336/1024/1024`.
+Expected baseline: 121 passing tests and split sizes `14336/1024/1024`.
 
 ## 4. Reproduce ECP-6
 
@@ -71,7 +71,7 @@ This reruns a known experiment. It must not be presented as a new independent co
 
 ## 5. Continue ECP-7 scientifically
 
-Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 23
+Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 24
 configs. ECP7-B1-I collapsed to 130–139 hard messages. ECP7-B2-I improved its
 soft objective but collapsed further to 85–104 hard messages. ECP7-B3-I applied
 that loss to straight-through hard messages and improved to 585–972 messages,
@@ -140,11 +140,15 @@ shared-error pool reached 1,414 during sender-only routing, then jumped to 1,984
 at the first joint boundary and reached 2,085 at selection. The any-link pool
 fell to 2,660, but validation remained 83.50%, train exactness and injectivity
 still failed, and the confirmatory ECP-7 test remains sealed.
+ECP7-B24-I made the post-warmup replay phase receiver-only. It set new ECP-7
+bests of 84.69% mean train, 84.48% mean validation and 84.55% translator
+validation, but worst-link validation remained 82.23%, sender injectivity
+failed and the confirmatory ECP-7 test remains sealed.
 
 Continue with this sequence:
 
 1. Read `docs/research-design-ecp7.md` and `docs/development-log-ecp7.md`.
-2. Define exactly one ECP7-B24 intervention and its failure criterion.
+2. Define exactly one ECP7-B25 intervention and its failure criterion.
 3. Register the variant and immutable configuration hashes before training.
 4. Add tests for every new invariant.
 5. Use only `smoke` and `develop`; keep the ECP-7 test split sealed.
@@ -157,26 +161,27 @@ Continue with this sequence:
 
 ## 6. Recommended next experiment
 
-Batch 23 confirms that restoring joint replay after sender-only warmup promptly
-recreates shared errors. Batch 22 confirms that staying sender-only instead
-creates cross-link fragmentation. The clean remaining routing question is
-whether receivers can catch up without letting the replay branch move sender
-codes again. A clean ECP7-B24 progression is:
+Batch 24 confirms that receiver-only replay catch-up improves all mean metrics
+but retains cross-link fragmentation and non-injective sender codes. Its best
+checkpoint occurs at step 29,400, only 600 steps before the fixed horizon, so
+the registered patience could not test a late plateau. A clean ECP7-B25
+progression is:
 
-- inherit the complete Batch 23 implementation, Batch 21 predicate and Batch 15
-  base;
-- keep replay sender-only during steps 15,000–20,000, then make the additional
-  replay branch receiver-only by detaching sender messages after step 20,000;
+- inherit the complete Batch 24 implementation and configuration;
+- change only `training.max_steps` from `30,000` to `45,000`;
+- keep the 5,000-step early-stopping patience and minimum selection step
+  unchanged, so the run may stop before 45,000 if a genuine plateau occurs;
 - keep ordinary base-task updates to both senders and receivers unchanged;
 - keep weight `0.25`, the 64-meaning replay batch, 200-step refresh,
-  seed-derived sampler, predicate, temperature and horizon unchanged;
+  seed-derived sampler, predicate and temperature unchanged;
 - continue to mine and replay training meanings only;
 - measure shared and any-link pool sizes, train exactness, injectivity,
   validation and new-reader induction, and rerun the frozen ECP-6 control.
 
-Do not combine the routing schedule with another predicate, coefficient, graded
+Do not combine the horizon change with another predicate, coefficient, graded
 sampling, collision pressure, a new architecture, factor-specific weights,
-optimizer changes, longer training, variable-length messages or negotiation.
+optimizer changes, a second horizon change, variable-length messages or
+negotiation.
 
 ## 7. Definition of done for any contribution
 
 
@@ -31,6 +31,7 @@ this log.
 | ECP7-B21-I | Intervention | B20 replay restricted to meanings failed by all 16 links | Position-aware MLP | valid negative; new-best validation 83.63%, shared-error pool grows |
 | ECP7-B22-I | Intervention | B21 replay gradients routed to senders but not receiver parameters | Position-aware MLP | valid negative; shared errors fall but link-specific fragmentation rises |
 | ECP7-B23-I | Intervention | B22 sender-only replay warmup followed by restored joint replay gradients | Position-aware MLP | valid negative; joint phase recreates shared errors without improving accuracy |
+| ECP7-B24-I | Intervention | B23 sender-only warmup followed by receiver-only replay catch-up | Position-aware MLP | valid negative; new-best means but link-specific errors and injectivity fail |
 
 ## Batch 1 preregistration
 
@@ -1875,3 +1876,109 @@ phase receiver-only rather than joint. Detaching replay messages after step
 20,000 would let receivers catch up to the sender-only code movement without
 allowing the replay branch to move those codes again. The ordinary task must
 remain joint throughout, and no other setting may change.
+
+## Batch 24 preregistration
+
+Preregistered: July 18, 2026 at 17:09:59 UTC<br>
+Seed: `11`<br>
+Maximum population steps: `30,000`<br>
+Minimum selection steps: `15,000`<br>
+Early-stopping patience: `5,000` steps<br>
+Hard-meaning predicate: all `16` current population links have an incorrect factor<br>
+Replay sender-message gradients: **enabled through step 20,000; disabled from step 20,001**<br>
+Replay receiver-parameter gradients: **disabled through step 20,000; enabled from step 20,001**<br>
+Ordinary-task sender and receiver gradients: **enabled throughout**<br>
+Replay weight: `0` through step `15,000`, linear to `0.25` at step `20,000`, then hold<br>
+Replay batch size: `64` meanings, uniform with replacement<br>
+Training-only pool refresh interval: `200` steps<br>
+Replay sampler seed offset: `+1211`<br>
+Raw configuration SHA-256: `27e737c1eaa3c191253469fb863171c9875e1e9433c2b00b7a578e15609155dc`<br>
+Effective configuration SHA-256: `a01f184249b32859074909039ba86d495854a3c5f063c19f5519e2739135cb9e`<br>
+Split-SHA-256: `4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd`<br>
+Test unsealed: **no**
+
+ECP7-B24-I inherits Batch 23 and changes only sender-message gradient routing
+for the additional replay branch after step 20,000. Replay is sender-only
+through the registered warmup and receiver-only afterward. Receiver-only replay
+detaches the sampled sender messages before reconstruction, while the ordinary
+task continues to update both senders and receivers. Gradient invariant tests
+cover each isolated replay phase and both ordinary-task routes. The positive
+control is rerun, and no alternative switch point, routing, predicate or
+accompanying intervention is admitted into this batch.
+
+## Batch 24 results
+
+Positive-control run: `runs/ecp7-batch24-control-development/20260718T171239Z-ecp7-development`<br>
+Intervention run: `runs/ecp7-batch24-intervention-development/20260718T171239Z-ecp7-development`<br>
+Test unsealed: **no**
+
+| Metric | Positive control | ECP7-B24-I |
+|---|---:|---:|
+| Population train, mean | 100% | **84.6854%** |
+| Population train, worst link | 100% | 82.5614% |
+| Population validation, mean | 100% | **84.4849%** |
+| Population validation, worst link | 100% | 82.2266% |
+| Universal translator, validation | 100% | **84.5459%** |
+| Exact sender-message agreement | 100% | 91.50% |
+| Unique messages per sender | 15,360 | 12,720–13,440 |
+| Collision meanings per sender | 0 | 1,920–2,640 |
+| Message entropy | 13.91 bits | 13.54–13.64 bits |
+| Development gate | pass | **fail** |
+
+The positive control passed every gate at 100%. ECP7-B24-I sets new ECP-7
+development bests for mean train, mean validation and universal-translator
+validation. It still fails both train thresholds and sender injectivity, while
+worst-link validation is below Batch 21. The joint gate fails and confirmatory
+access remains unauthorized.
+
+All 101 optimization records through step 20,000 match Batch 23 and Batch 22
+exactly across their shared fields. Every history record confirms the
+registered routes: sender-only replay through step 20,000 and receiver-only
+replay from the next boundary at step 20,200. The all-link pool follows the
+common trajectory from 1,745 to a
+minimum of 1,414 at step 18,200 and 1,579 at step 20,000.
+
+The first receiver-only boundary still observes 1,984 all-link failures, because
+pool mining precedes that boundary's update. Unlike joint B23, subsequent
+receiver-only updates reduce that pool again: it contains 1,990 meanings at
+step 22,000, 1,690 at the selected step 29,400 and 1,710 at the final step
+30,000. The selected checkpoint is at the end of the available horizon rather
+than an early-stopping plateau.
+
+The selected diagnostic finds 1,690 meanings failed by all links and 3,142
+failed by at least one link. Mean failed links among those meanings is 11.18.
+This is close to Batch 22's sender-only pattern of 1,513 shared and 3,197
+any-link failures, but the receiver catch-up phase raises mean train by 1.01
+percentage points and mean validation by 0.98 points relative to B22. It does
+not repair the fragmented worst-link bottleneck.
+
+Compared with Batch 21, B24 improves mean train by 0.98 percentage points, mean
+validation by 0.85 points and translator validation by 0.90 points. Worst-link
+train falls by 0.23 points, worst-link validation by 0.39 points, and sender
+agreement by 1.46 points. Receiver-only replay therefore improves the average
+code-reader fit while increasing population imbalance.
+
+Selected sender codebooks contain 13,214, 12,955, 12,720 and 13,440 unique
+messages, with 2,146, 2,405, 2,640 and 1,920 collision meanings. Population
+validation factor accuracies were `[99.98%, 99.87%, 98.44%, 86.17%]`;
+universal-translator factor accuracies were
+`[100%, 100%, 98.44%, 86.11%]`. Texture improves, while the fixed size
+collision pattern and sender-specific texture differences remain.
+
+Both sealed analyses report 65 matching artifact hashes, 16,384 validation-only
+episodes, no confirmatory-test keys, valid local alphabets, and exactly 14
+declared bits for every logged message.
+
+## Batch 24 decision
+
+ECP7-B24-I is a valid negative result and the strongest mean-performance ECP-7
+development variant so far. Receiver-only catch-up is better than joint replay
+for mean reconstruction, but it does not solve injectivity or worst-link
+generalization. The confirmatory split remains sealed.
+
+The selected checkpoint occurs at step 29,400 and training reaches the 30,000
+step cap before the registered 5,000-step patience can evaluate a late plateau.
+A future ECP7-B25 may inherit Batch 24 unchanged and extend only `max_steps` to
+45,000. This isolates whether the receiver-only phase is still improving or
+merely approaching a non-injective plateau. No coefficient, route, predicate,
+architecture, optimizer or data setting may change with that horizon test.
@@ -1013,3 +1013,43 @@ sealed-test requirement fails. No alternative switch step, gradient route,
 predicate, coefficient, replay batch, refresh, architecture, base loss,
 optimizer, duration, data, translator or seed may be tried inside Batch 23.
 Failure is recorded without confirmatory test access.
+
+## Batch 24 preregistration — Receiver-only replay catch-up
+
+Status: **preregistered for sealed development**<br>
+Preregistered: July 18, 2026 at 17:09:59 UTC<br>
+Configuration: `config/ecp7-b24-development.yaml`<br>
+Raw configuration SHA-256: `27e737c1eaa3c191253469fb863171c9875e1e9433c2b00b7a578e15609155dc`<br>
+Effective configuration SHA-256: `a01f184249b32859074909039ba86d495854a3c5f063c19f5519e2739135cb9e`
+
+Batch 22's sender-only replay separated population-shared failures but created
+link-specific fragmentation. Batch 23 restored joint replay after warmup and
+immediately recreated shared failures. Batch 24 isolates the remaining routing
+hypothesis: let receivers catch up to the separated codes without allowing the
+additional replay loss to move sender codes again.
+
+ECP7-B24-I inherits the complete Batch 23 implementation, Batch 21 predicate,
+Batch 20 replay mechanism, Batch 15 architecture, ordinary task batch,
+utilization objective, optimizer, data, temperature schedule, coefficient,
+replay batch, sampler, refresh, warmup, 30,000-step horizon, selection,
+translator and thresholds. The sole change is:
+
+- after step 20,000, the additional hard-replay branch detaches sender messages,
+  making that branch receiver-only instead of joint.
+
+Replay remains sender-only through step 20,000. The ordinary base task updates
+both senders and receivers at every step. Mining still uses hard training
+predictions only. The complete optimization trajectory through step 20,000
+must match Batch 23 and Batch 22 exactly.
+
+The batch contains exactly two seed-11 runs:
+
+1. the unchanged ECP-6 positive control;
+2. ECP7-B24-I with sender-only then receiver-only hard replay.
+
+All existing validity and development gates remain unchanged. The intervention
+fails if any train, validation, translator, injectivity, channel-integrity or
+sealed-test requirement fails. No alternative switch step, gradient route,
+predicate, coefficient, replay batch, refresh, architecture, base loss,
+optimizer, duration, data, translator or seed may be tried inside Batch 24.
+Failure is recorded without confirmatory test access.
@@ -130,6 +130,12 @@ reached 2,085 at selection. The any-link pool improved to 2,660, but validation
 remained 83.50% and injectivity still failed. Exact identities and hashes are in
 `batch23-manifest.json`.
 
+Batch 24 changed the second replay phase from joint to receiver-only. It reached
+new-best means of 84.69% train, 84.48% validation and 84.55% translator
+validation. The selected error pool contains 1,690 shared failures and 3,142
+any-link failures, so worst-link accuracy and injectivity still fail. Exact
+identities and hashes are in `batch24-manifest.json`.
+
 Reproduce the development arms with:
 
 ```bash