@@ -62,7 +62,10 @@ Batch 27 directly penalized globally mined sender collisions after step 30,000.
 It reduced collision multiplicity and reached 85.38% validation, but unique
 code counts again remained unchanged and worst-link validation regressed to
 82.13%. Both replay routing and the existing collision-loss schedule are now
-closed; future work must change sender representation or code occupancy. See
+closed. Batch 28 added an identity-initialized generic residual sender block,
+but it collapsed to 9.65% validation and roughly 8,000 unique messages. Generic
+depth active from the start promotes memorization rather than compositional
+generalization. See
 [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md).
 
 ## Build on this work
@@ -130,6 +133,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`config/ecp7-b25-development.yaml`](config/ecp7-b25-development.yaml) — Batch 24 receiver-only catch-up with an isolated 45,000-step maximum horizon.
 - [`config/ecp7-b26-development.yaml`](config/ecp7-b26-development.yaml) — Batch 25 with one preregistered sender/receiver replay-route cycle.
 - [`config/ecp7-b27-development.yaml`](config/ecp7-b27-development.yaml) — Batch 25 plus one late bounded direct sender-collision pulse.
+- [`config/ecp7-b28-development.yaml`](config/ecp7-b28-development.yaml) — Batch 25 with one zero-initialized shared residual sender interaction.
 - [`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-b25-development.yaml
+
+experiment:
+  title: ECP-7 identity-preserving residual parallel sender
+  arm: identity_preserving_residual_parallel_sender
+  objective: >-
+    Test whether one zero-initialized shared residual interaction layer can
+    break the stable sender code-capacity ceiling while preserving the
+    successful shallow joint-context path and all meaning-free constraints.
+
+agents:
+  sender:
+    family: residual_bounded_parallel_sender
@@ -41,7 +41,7 @@ python3.12 -m venv .venv
 .venv/bin/ecp6 --config config/ecp6.yaml validate
 ```
 
-Expected baseline: 127 passing tests and split sizes `14336/1024/1024`.
+Expected baseline: 130 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 27
+Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 28
 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,
@@ -161,11 +161,16 @@ exactly the same 13,440, 12,960, 12,720 and 13,440 unique-message counts as
 Batch 25. Worst-link validation regressed to 82.13%, so the existing collision
 loss is also closed as a capacity solution. The confirmatory test remains
 sealed.
+ECP7-B28-I added one zero-initialized shared residual sender interaction. Tests
+prove an identical initial function and unchanged RNG state, but the trainable
+branch still collapsed to 53.91% train, 9.65% validation, 11.62% translator
+validation and only 7,928–8,333 messages. Generic sender depth active from the
+first update is therefore rejected. The confirmatory 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-B28 sender-representation or occupancy intervention and its
+2. Define at most one ECP7-B29 late-activation residual intervention and its
    failure criterion.
 3. Register the variant and immutable configuration hashes before training.
 4. Add tests for every new invariant.
@@ -179,20 +184,21 @@ Continue with this sequence:
 
 ## 6. Recommended next experiment
 
-Batch 27 shows that the existing relaxed collision-pair loss can reduce
-collision multiplicity but cannot create newly occupied hard codes. Do not try
-another coefficient, pulse boundary, route cycle or horizon extension.
-
-For ECP7-B28, preregister exactly one factor-agnostic sender representation or
-genuinely different occupancy-creation intervention. A defensible
-representation candidate is an identity-preserving residual interaction block
-on the successful bounded-parallel sender: retain the complete shallow joint
-context and slot heads, add one shared nonlinear residual branch initialized to
-zero output, and change no receiver, loss, data or training schedule. This
-isolates whether missing joint-context interaction capacity caused the stable
-code ceiling while avoiding Batch 13's replacement of the successful shallow
-path. Do not combine it with collision replay, a new coefficient, factor-slot
-bindings, optimizer changes, variable-length messages or negotiation.
+Batch 28 shows that identity initialization alone does not protect the shallow
+compositional trajectory: a residual branch trainable from step 1 rapidly
+becomes dominant and memorizes the training relation. Do not try another
+always-active generic layer, width or activation.
+
+At most one ECP7-B29 residual follow-up is justified: inherit B28's exact
+zero-RNG representation and B25's complete training setup, freeze the residual
+weight and bias at zero through step 30,000, then activate only those parameters
+for the remaining registered horizon. The purpose is to isolate whether late
+representation capacity can split an already established code without
+relearning the compositional protocol. Predefine one activation boundary and
+do not combine it with collision replay, gradient-route changes, a new loss,
+factor-slot bindings, optimizer changes, variable-length messages or
+negotiation. If this also fails, close ECP-7 development rather than continue a
+residual schedule search.
 
 ## 7. Definition of done for any contribution
 
 
@@ -35,6 +35,7 @@ this log.
 | ECP7-B25-I | Intervention | B24 receiver-only catch-up with a 45,000-step maximum horizon | Position-aware MLP | valid negative; new-best means reach the non-injective code-cap |
 | ECP7-B26-I | Intervention | B25 with a second sender-only pulse and final receiver-only catch-up | Position-aware MLP | valid negative; route cycle changes error sharing but not code capacity |
 | ECP7-B27-I | Intervention | B25 plus one late bounded direct sender-collision pulse | Position-aware MLP | valid negative; collision multiplicity falls but unique-code capacity is unchanged |
+| ECP7-B28-I | Intervention | B25 with one zero-initialized shared sender residual interaction | Position-aware MLP | valid negative; generic residual depth drives memorization and code collapse |
 
 ## Batch 1 preregistration
 
@@ -2288,3 +2289,107 @@ The ECP-7 confirmatory split remains sealed. A future batch must change the
 factor-agnostic sender representation or introduce a genuinely different
 occupancy-creation mechanism; it may not combine that change with another
 replay-route or collision-coefficient search.
+
+## Batch 28 preregistration
+
+Preregistered: July 18, 2026 at 18:30:20 UTC<br>
+Seed: `11`<br>
+Maximum population steps: `45,000`<br>
+Minimum selection steps: `15,000`<br>
+Early-stopping patience: `5,000` steps<br>
+Base architecture: B25 bounded-parallel sender and position-aware MLP receiver<br>
+Representation addition: one shared hidden-to-hidden residual projection<br>
+Residual activation: `tanh`<br>
+Residual weight and bias initialization: exact zero<br>
+Factor-specific sender paths or bindings: **none**<br>
+Additional collision loss: **none**<br>
+Raw configuration SHA-256: `1ce3094d0e372f4b052773a2c44d1abe36cd6255aea96f4218c175e5f93977d7`<br>
+Effective configuration SHA-256: `7bb7c2c185ed46f580464fe4364b8070bf5fdb071d3d64b16ec66b7fbe7ec307`<br>
+Split-SHA-256: `4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd`<br>
+Test unsealed: **no**
+
+ECP7-B28-I inherits Batch 25 and changes only the sender family. The successful
+shallow joint context and four capacity-bounded slot heads remain intact. A
+single shared projection learns an additive `tanh` correction to that context.
+Its parameters are constructed directly as zeros, so the new branch contributes
+exactly zero and consumes no random draws at initialization. Under the same
+seed, every pre-existing sender parameter and all later agent initialization
+therefore remain identical to the B25 base before optimization begins.
+
+The positive control is rerun. All existing validity and development gates
+remain unchanged. The representation hypothesis also requires a selected
+minimum sender codebook larger than Batch 25's 12,720-message minimum without a
+lower worst-link validation score. No collision replay from Batch 27, new loss,
+residual width, activation, initialization, receiver change, route change,
+optimizer, horizon, data, translator or seed may be tried inside Batch 28.
+Failure is recorded without confirmatory test access.
+
+## Batch 28 results
+
+Positive-control run: `runs/ecp7-batch28-control-development/20260718T183206Z-ecp7-development`<br>
+Intervention run: `runs/ecp7-batch28-intervention-development/20260718T183329Z-ecp7-development`<br>
+Test unsealed: **no**
+
+| Metric | Positive control | ECP7-B28-I |
+|---|---:|---:|
+| Population train, mean | 100% | 53.9063% |
+| Population train, worst link | 100% | 53.1180% |
+| Population validation, mean | 100% | 9.6497% |
+| Population validation, worst link | 100% | 8.1055% |
+| Universal translator, validation | 100% | 11.6211% |
+| Exact sender-message agreement | 100% | 83.80% |
+| Unique messages per sender | 15,360 | 7,928–8,333 |
+| Collision meanings per sender | 0 | 7,027–7,432 |
+| Message entropy | 13.91 bits | 12.65–12.76 bits |
+| Development gate | pass | **fail** |
+
+The positive control passed every gate at 100%. ECP7-B28-I fails train,
+validation, translator, injectivity and the added representation criterion by
+large margins. Its selected checkpoint occurs at step 17,000; patience stops
+training at step 22,000. The joint gate fails and confirmatory access remains
+unauthorized.
+
+Implementation tests prove that the residual sender initially has the same
+pre-existing weights and hard messages as the shallow B25 sender and consumes
+no additional random draws. The first optimization update is nevertheless
+allowed to move the zero residual parameters, so the learned trajectories
+diverge immediately. At step 200 B28 already fits training faster than B25
+(2.35% versus 1.49%), but by step 1,000 its validation is only 0.63% versus
+B25's 1.95%. At step 5,000 B28 reaches 41.69% train and 2.23% validation,
+where B25 reaches 71.27% and 52.39%.
+
+This gap keeps widening. At step 15,000 B28 has 53.21% train but only 9.42%
+validation, compared with B25's 82.08% train and 72.98% validation. The
+selected residual weight norms are 23.16–23.39 and bias norms are 1.32–1.49;
+the initially null branch has become a dominant transformation rather than a
+small correction.
+
+Selected sender codebooks contain only 7,928, 7,987, 8,333 and 8,150 unique
+messages. The selected diagnostic finds 3,902 meanings failed by all links and
+8,720 failed by at least one link, with 12.12 mean failed links per erroneous
+meaning. The all-link replay pool reaches a minimum of 3,716 at step 18,600 and
+then regrows to 4,139 at the final step.
+
+Population validation factor accuracies were
+`[80.33%, 25.42%, 99.85%, 96.20%]`; universal-translator factor accuracies were
+`[80.62%, 26.51%, 99.80%, 96.73%]`. The residual model largely memorizes the
+training relation for the held-out shape dimension instead of preserving the
+shallow model's compositional color-shape generalization.
+
+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 28 decision
+
+ECP7-B28-I is a valid negative result. Identity-preserving initialization does
+not preserve the successful optimization path when generic residual capacity
+is trainable from the first update. Like Batch 13's replacement layer, the
+residual layer promotes training-set memorization, code collapse and severe
+compositional-generalization loss.
+
+The ECP-7 confirmatory split remains sealed. Generic sender depth from the
+start of training is closed. If one final residual test is attempted, it must
+freeze the exact-zero branch through the already successful B25 trajectory and
+activate only that representation afterward; no architectural, objective or
+route change may accompany it.
@@ -1205,3 +1205,60 @@ minimum-capacity/worst-link criterion without accessing the confirmatory split.
 This closes coefficient and timing development for the existing relaxed
 collision-pair loss. Any later batch must preregister a distinct sender
 representation or occupancy-creation mechanism.
+
+## Batch 28 preregistration — Identity-preserving residual parallel sender
+
+Status: **completed sealed development; valid negative**<br>
+Preregistered: July 18, 2026 at 18:30:20 UTC<br>
+Configuration: `config/ecp7-b28-development.yaml`<br>
+Raw configuration SHA-256: `1ce3094d0e372f4b052773a2c44d1abe36cd6255aea96f4218c175e5f93977d7`<br>
+Effective configuration SHA-256: `7bb7c2c185ed46f580464fe4364b8070bf5fdb071d3d64b16ec66b7fbe7ec307`
+
+Batch 13 replaced the successful shallow sender context with an additional
+nonlinear layer and collapsed. Batches 25–27 now show a stable hard-code
+capacity ceiling that receiver training, replay routing and direct collision
+pressure do not cross. Batch 28 isolates a representation hypothesis without
+discarding the shallow path: add one identity-preserving residual interaction
+to the shared joint context.
+
+ECP7-B28-I inherits the full Batch 25 configuration, including its 45,000-step
+horizon, receiver-only hard-meaning replay after step 20,000, architecture on
+the receiver side, losses, optimizer, data, temperature, selection, translator
+and thresholds. The sole configuration change is the sender family from
+`bounded_parallel_sender` to `residual_bounded_parallel_sender`.
+
+The new sender first computes the unchanged shallow context. It then adds
+`tanh(W context + b)` before the unchanged slot heads. `W` and `b` are created
+as exact zero tensors without consuming random draws. Consequently the residual
+sender has exactly the same initial discrete messages and pre-existing
+parameters as the shallow sender under the same seed, while its residual
+parameters receive gradients immediately. The branch is shared by all slots
+and sees only the joint context; it has no factor-local projection, factor-slot
+binding, semantic symbol assignment or capacity change.
+
+The batch contains exactly two seed-11 runs:
+
+1. the unchanged ECP-6 positive control;
+2. ECP7-B28-I with the residual bounded-parallel sender.
+
+All existing validity and development gates remain unchanged. Additionally,
+the representation claim requires the selected minimum unique-message count to
+exceed Batch 25's 12,720 while worst-link validation is at least Batch 25's
+82.7148%. No Batch 27 collision loss, alternative residual width, activation,
+initialization, receiver, replay route, base loss, optimizer, horizon, data,
+translator or seed may be tried inside Batch 28. Failure is recorded without
+confirmatory test access.
+
+### Batch 28 outcome
+
+The registered seed-11 residual sender reached 53.91% mean train, 53.12%
+worst-link train, 9.65% mean validation, 8.11% worst-link validation and 11.62%
+universal-translator validation. Its sender codebooks collapsed to 7,928–8,333
+unique messages. Although tests prove exact functional and RNG-equivalent
+initialization, the trainable residual rapidly became dominant and destroyed
+the shallow sender's compositional trajectory. It failed every performance and
+injectivity gate without accessing the confirmatory split.
+
+This closes generic sender-depth changes active from the start of training. A
+future residual experiment is justified only as a single late-activation test
+that preserves the complete established shallow trajectory before unfreezing.
@@ -158,6 +158,13 @@ message entropy, but produced exactly the same unique-message counts as Batch
 therefore reshapes occupied codes without creating new ones. Exact identities
 and hashes are in `batch27-manifest.json`.
 
+Batch 28 added one zero-initialized shared residual interaction to the
+bounded-parallel sender. Despite exact functional and RNG-equivalent
+initialization, the trainable branch collapsed code use to 7,928–8,333 messages
+and validation to 9.65%. Generic sender depth active from the first update
+therefore promotes memorization rather than compositional generalization. Exact
+identities and hashes are in `batch28-manifest.json`.
+
 Reproduce the development arms with:
 
 ```bash