@@ -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-two sealed batches are valid
+one-factor-per-slot architecture. Its first twenty-three 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
@@ -46,7 +46,9 @@ exactness and injectivity. Batch 21 restricted replay to errors shared by all
 but its target error pool grew and train exactness still failed. The ECP-7
 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%. See
+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
 [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md).
 
 ## Build on this work
@@ -109,6 +111,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`config/ecp7-b20-development.yaml`](config/ecp7-b20-development.yaml) — late ordinary task replay on population-hard training meanings.
 - [`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-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-b22-development.yaml
+
+experiment:
+  title: ECP-7 phased population-shared hard replay
+  arm: phased_population_shared_hard_replay
+  objective: >-
+    Test whether a sender-only replay warmup followed by restored joint replay
+    gradients can preserve early shared-error separation while allowing
+    receivers to realign with the moved sender codes.
+
+training:
+  global_hard_meaning_replay:
+    enable_receiver_parameter_gradients_after_step: 20000
@@ -41,7 +41,7 @@ python3.12 -m venv .venv
 .venv/bin/ecp6 --config config/ecp6.yaml validate
 ```
 
-Expected baseline: 114 passing tests and split sizes `14336/1024/1024`.
+Expected baseline: 117 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 22
+Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 23
 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,
@@ -135,11 +135,16 @@ loss. Its shared-error pool fell from 1,745 to 1,513 at selection, but the total
 any-link pool grew to 3,197, sender agreement fell to 92.06% and validation
 regressed to 83.51%. Train thresholds and injectivity still failed, and the
 confirmatory ECP-7 test remains sealed.
+ECP7-B23-I restored joint replay gradients after the sender-only warmup. The
+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.
 
 Continue with this sequence:
 
 1. Read `docs/research-design-ecp7.md` and `docs/development-log-ecp7.md`.
-2. Define exactly one ECP7-B23 intervention and its failure criterion.
+2. Define exactly one ECP7-B24 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.
@@ -152,16 +157,16 @@ Continue with this sequence:
 
 ## 6. Recommended next experiment
 
-Batch 22 confirms that sender-only replay reduces shared errors, but receivers
-cannot follow the moving codes quickly enough: any-link failures rise and
-agreement falls. Batch 21 shows the opposite joint-routing behavior. The clean
-next question is whether routing should be phased rather than permanent. A clean
-ECP7-B23 progression is:
+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:
 
-- inherit the complete Batch 22 implementation, Batch 21 predicate and Batch 15
+- inherit the complete Batch 23 implementation, Batch 21 predicate and Batch 15
   base;
-- keep replay sender-only only during its registered steps 15,000–20,000
-  warmup, then restore receiver-parameter replay gradients after step 20,000;
+- 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;
 - 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;
 
@@ -30,6 +30,7 @@ this log.
 | ECP7-B20-I | Intervention | Late global replay of population-hard training meanings | Position-aware MLP | valid negative; new-best validation 83.45%, train and injectivity fail |
 | 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 |
 
 ## Batch 1 preregistration
 
@@ -1773,3 +1774,104 @@ gradients for replay after the registered warmup. This tests whether an initial
 code-separation phase followed by joint decoder catch-up can combine B22's
 shared-error reduction with B21's population alignment. No other parameter,
 predicate or mechanism may change.
+
+## Batch 23 preregistration
+
+Preregistered: July 18, 2026 at 16:51:26 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 receiver-parameter gradients: **disabled through step 20,000; enabled from step 20,001**<br>
+Ordinary-task receiver-parameter 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: `8e0f7ed9b4d9a487bf0700be85e922142aafa3f8ccadf28326227bace6b78015`<br>
+Effective configuration SHA-256: `60f46c913a95077a9f40df695adf6bb9b8788f581c83a12deb35c1f9ca015fb9`<br>
+Split-SHA-256: `4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd`<br>
+Test unsealed: **no**
+
+ECP7-B23-I inherits Batch 22 and changes only the replay receiver-gradient
+routing schedule. Its additional replay branch is sender-only during the
+registered weight warmup and becomes joint after step 20,000. The ordinary
+task remains joint throughout. An invariant test fixes the inclusive boundary:
+receiver parameters are excluded at step 20,000 and included at step 20,001.
+The positive control is rerun, and no alternative switch point, routing,
+predicate or accompanying intervention is admitted into this batch.
+
+## Batch 23 results
+
+Positive-control run: `runs/ecp7-batch23-control-development/20260718T165354Z-ecp7-development`<br>
+Intervention run: `runs/ecp7-batch23-intervention-development/20260718T165354Z-ecp7-development`<br>
+Test unsealed: **no**
+
+| Metric | Positive control | ECP7-B23-I |
+|---|---:|---:|
+| Population train, mean | 100% | **83.7197%** |
+| Population train, worst link | 100% | 82.7148% |
+| Population validation, mean | 100% | **83.4961%** |
+| Population validation, worst link | 100% | 82.3242% |
+| Universal translator, validation | 100% | **83.6182%** |
+| Exact sender-message agreement | 100% | 92.31% |
+| Unique messages per sender | 15,360 | 12,705–13,199 |
+| Collision meanings per sender | 0 | 2,161–2,655 |
+| Message entropy | 13.91 bits | 13.54–13.61 bits |
+| Development gate | pass | **fail** |
+
+The positive control passed every gate at 100%. ECP7-B23-I passes validation and
+translator thresholds but fails both train thresholds and sender injectivity.
+It does not improve a primary performance metric over Batch 21. The joint gate
+fails and confirmatory access remains unauthorized.
+
+All 101 optimization records through step 20,000 match Batch 22 exactly. The
+routing invariant is also visible in every history record: replay receiver
+gradients are disabled through step 20,000 and enabled from the next recorded
+boundary at step 20,200. The all-link pool starts at 1,745 meanings, reaches a
+minimum of 1,414 at step 18,200, and contains 1,579 meanings when the sender-only
+phase ends at step 20,000.
+
+Restoring joint replay immediately reverses that separation. The all-link pool
+jumps to 1,984 at step 20,200, reaches 2,085 at the selected step 23,200, and
+ends at 1,979 when patience stops training at step 28,200. The selected
+checkpoint diagnostic confirms 2,085 meanings failed by all 16 links. It has
+2,660 meanings failed by at least one link, lower than Batch 21's 2,755 and
+Batch 22's 3,197, while the mean number of failed links among those meanings is
+14.04. The receiver catch-up phase therefore reduces fragmented errors but
+reconcentrates them into population-shared ambiguity.
+
+Compared with Batch 21, mean validation falls by 0.13 percentage points,
+worst-link validation by 0.29 points, translator validation by 0.02 points and
+sender agreement by 0.66 points. Mean train is effectively unchanged. Batch 21
+retains the strongest validation and agreement results. Compared with Batch 22,
+B23 recovers 0.25 points of sender agreement and 0.02 points of translator
+validation, but mean validation is effectively unchanged and the shared-error
+pool is substantially larger.
+
+Selected sender codebooks contain 12,960, 12,870, 12,705 and 13,199 unique
+messages, with 2,400, 2,490, 2,655 and 2,161 collision meanings. Population
+validation factor accuracies were `[99.87%, 99.91%, 98.44%, 85.25%]`;
+universal-translator factor accuracies were
+`[100%, 100%, 98.44%, 85.18%]`. The persistent size and texture bottlenecks are
+unchanged.
+
+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 23 decision
+
+ECP7-B23-I is a valid negative result. A sender-only warmup followed by joint
+replay does not combine the advantages of B21 and B22: joint replay promptly
+recreates shared errors, while accuracy and injectivity remain unchanged. The
+confirmatory split remains sealed.
+
+The routing schedule itself is now sufficiently isolated: permanent joint,
+permanent sender-only and sender-only-to-joint replay all fail differently. A
+future ECP7-B24 may preserve the Batch 23 schedule but make the second replay
+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.
@@ -972,3 +972,44 @@ sealed-test requirement fails. No alternative gradient route, predicate,
 coefficient, replay batch, refresh, schedule, architecture, base loss,
 optimizer, duration, data, translator or seed may be tried inside Batch 22.
 Failure is recorded without confirmatory test access.
+
+## Batch 23 preregistration — Phased shared-error replay routing
+
+Status: **preregistered for sealed development**<br>
+Preregistered: July 18, 2026 at 16:51:26 UTC<br>
+Configuration: `config/ecp7-b23-development.yaml`<br>
+Raw configuration SHA-256: `8e0f7ed9b4d9a487bf0700be85e922142aafa3f8ccadf28326227bace6b78015`<br>
+Effective configuration SHA-256: `60f46c913a95077a9f40df695adf6bb9b8788f581c83a12deb35c1f9ca015fb9`
+
+Batch 21's joint replay preserved population alignment but grew the shared-error
+pool. Batch 22's sender-only replay reduced that pool but increased fragmented
+any-link errors and reduced sender agreement. Batch 23 isolates whether the two
+routing modes are useful in sequence: first move ambiguous sender codes against
+fixed receivers, then allow receivers to catch up.
+
+ECP7-B23-I inherits the complete Batch 22 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:
+
+- the additional hard-replay branch keeps receiver parameters fixed through
+  step 20,000 and restores receiver-parameter gradients from step 20,001.
+
+The replay loss remains zero through step 15,000 and warms linearly 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 15,000 must match B22, B21, B20 and B15
+exactly; through step 20,000 it must match B22.
+
+The batch contains exactly two seed-11 runs:
+
+1. the unchanged ECP-6 positive control;
+2. ECP7-B23-I with phased population-shared 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 23.
+Failure is recorded without confirmatory test access.
@@ -123,6 +123,13 @@ any-link pool grew to 3,197 and validation regressed to 83.51%. Sender-only
 routing therefore trades shared ambiguity for cross-link fragmentation. Exact
 identities and hashes are in `batch22-manifest.json`.
 
+Batch 23 kept the Batch 22 sender-only warmup through step 20,000 and then
+restored joint replay gradients. The shared-error pool fell to 1,414 during the
+sender-only phase but jumped to 1,984 at the first joint phase boundary and
+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`.
+
 Reproduce the development arms with:
 
 ```bash
 
@@ -0,0 +1,57 @@
+{
+  "batch": "ECP7-B23",
+  "confirmatory_test_unsealed": false,
+  "config_effective_sha256": "60f46c913a95077a9f40df695adf6bb9b8788f581c83a12deb35c1f9ca015fb9",
+  "config_raw_sha256": "8e0f7ed9b4d9a487bf0700be85e922142aafa3f8ccadf28326227bace6b78015",
+  "control": {
+    "artifact_hashes": {
+      "effective_config.yaml": "4bfb976293f117d3ae35f790e4fd6371628be95d91febb334bc275dc5d6b66d4",
+      "posthoc-analysis.json": "c00039440f19eed367c76239cfe81cdfc11b473e054f52cf6c84dfcb860466d9",
+      "seed-11/metrics.json": "512fe2d262d16ecf4fa6ea4992250f1cd7e0c2647d7a16f5395267c835466d24",
+      "summary.json": "527c8f7488bb795ed0866a5a62e817e78c5eee75052ef6bd9236201cd0cd8f3b"
+    },
+    "development_gate_passed": true,
+    "population_train_mean_exact_match": 1.0,
+    "population_validation_mean_exact_match": 1.0,
+    "run_id": "20260718T165354Z-ecp7-development",
+    "universal_translator_validation_exact_match": 1.0,
+    "unique_messages_per_sender": [15360, 15360, 15360, 15360]
+  },
+  "intervention": {
+    "artifact_hashes": {
+      "effective_config.yaml": "7570f38b6af4fd25d92d8a79b9dbc2837f1d91c5cc089ba2f6b213cbb9583362",
+      "posthoc-analysis.json": "1faf5ca496445a77017ee078e5830ed9ec574e2af18ef70aa03e3c2f2c0d618b",
+      "seed-11/metrics.json": "3d97e0c07aaaf32747dda4a14a4181799bd3f094313f7a75d791132d9d5f72d1",
+      "summary.json": "c045382367e7a4b476ad277de6526760039e44e087dab4d7cdbd46876821bb93"
+    },
+    "best_code_utilization_loss": -0.7546836137771606,
+    "best_global_hard_meaning_replay_loss": 0.12714391946792603,
+    "best_global_hard_meaning_replay_pool_size": 2085,
+    "best_global_hard_meaning_replay_weight": 0.25,
+    "best_step": 23200,
+    "collision_meanings_per_sender": [2400, 2490, 2655, 2161],
+    "development_gate_passed": false,
+    "exact_sender_message_agreement": 0.923068576388889,
+    "final_hard_meaning_replay_pool_size": 1979,
+    "final_step": 28200,
+    "initial_hard_meaning_replay_pool_size": 1745,
+    "message_entropy_bits_per_sender": [13.57551840805443, 13.56497916977656, 13.537597236165908, 13.607817711443227],
+    "minimum_hard_meaning_replay_pool_size": 1414,
+    "minimum_hard_meaning_replay_pool_step": 18200,
+    "population_train_mean_exact_match": 0.8371974400111607,
+    "population_train_worst_link_exact_match": 0.8271484375,
+    "population_validation_factor_accuracy": [0.9986572265625, 0.9991455078125, 0.984375, 0.8525390625],
+    "population_validation_mean_exact_match": 0.8349609375,
+    "population_validation_worst_link_exact_match": 0.8232421875,
+    "replay_receiver_parameter_gradients_after_step": 20000,
+    "run_id": "20260718T165354Z-ecp7-development",
+    "selected_all_links_wrong_meaning_count": 2085,
+    "selected_any_link_wrong_meaning_count": 2660,
+    "selected_mean_incorrect_links_per_hard_meaning": 14.038722038269043,
+    "universal_translator_validation_exact_match": 0.836181640625,
+    "unique_messages_per_sender": [12960, 12870, 12705, 13199]
+  },
+  "seed": 11,
+  "split_artifact_sha256": "676195997ee0c77d5c9565bae045dbb938b432a2e4e74b666233b0a41f924718",
+  "split_sha256": "4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd"
+}