@@ -25,9 +25,9 @@ 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-six sealed batches are valid
-development results but none passes the full gate. Batch 15 established the
+ECP-7 development tested how much of that result depends on the explicit
+one-factor-per-slot architecture. All 29 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
 12,585–13,200 hard messages per sender. Validation and translator thresholds pass
@@ -65,8 +65,13 @@ code counts again remained unchanged and worst-link validation regressed to
 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
+generalization. Batch 29 activated that branch only after the exact B25
+trajectory; it still reduced validation to 84.74% and removed occupied codes.
+ECP-7 development is therefore closed after 29 variants. No confirmatory ECP-7
+configuration was frozen and its confirmatory split was never opened. See
 [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md).
+The compact synthesis is in
+[`docs/ecp7-development-conclusion.md`](docs/ecp7-development-conclusion.md).
 
 ## Build on this work
 
@@ -106,6 +111,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`docs/protocol-specification-ecp6.md`](docs/protocol-specification-ecp6.md) — machine code, 14-bit wire format and induction procedure.
 - [`docs/research-design-ecp7.md`](docs/research-design-ecp7.md) — preregistered weak-structure question, paired control and sealed split.
 - [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md) — the first negative weak-structure batch and integrity checks.
+- [`docs/ecp7-development-conclusion.md`](docs/ecp7-development-conclusion.md) — sealed development synthesis and closure after 29 variants.
 - [`config/ecp7-development.yaml`](config/ecp7-development.yaml) — sealed weak-structure intervention configuration.
 - [`config/ecp7-b2-development.yaml`](config/ecp7-b2-development.yaml) — factor-agnostic soft code-utilization intervention.
 - [`config/ecp7-b3-development.yaml`](config/ecp7-b3-development.yaml) — the same utilization formula on straight-through hard messages.
@@ -134,6 +140,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`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-b29-development.yaml`](config/ecp7-b29-development.yaml) — Batch 28 with residual parameters frozen through step 30,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,14 @@
+extends: ecp7-b28-development.yaml
+
+experiment:
+  title: ECP-7 late residual sender activation
+  arm: late_residual_sender_activation
+  objective: >-
+    Test whether residual interaction capacity can split an already established
+    shallow protocol when kept exactly zero through step 30,000, without
+    disrupting the compositional learning trajectory from the start.
+
+training:
+  sender_residual_activation:
+    enabled: true
+    start_step: 30000
@@ -41,7 +41,7 @@ python3.12 -m venv .venv
 .venv/bin/ecp6 --config config/ecp6.yaml validate
 ```
 
-Expected baseline: 130 passing tests and split sizes `14336/1024/1024`.
+Expected baseline: 133 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 28
+Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 29
 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,
@@ -166,39 +166,38 @@ 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.
+ECP7-B29-I froze that residual branch at exact zero through step 30,000. All
+151 shared history records matched Batch 25, but late activation reduced the
+selected codebooks to 13,163, 12,960, 12,720 and 13,439 messages and worst-link
+validation to 81.74%. This final permitted residual test failed. ECP-7
+development is closed; no confirmatory configuration was frozen and the test
+split was never opened.
 
 Continue with this sequence:
 
 1. Read `docs/research-design-ecp7.md` and `docs/development-log-ecp7.md`.
-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.
-5. Use only `smoke` and `develop`; keep the ECP-7 test split sealed.
-6. Append every attempted variant and negative result to the development log.
-7. Select at most one final design using train and validation only.
-8. Create `config/ecp7.yaml` only after a design passes its development gate.
-9. Freeze its UTC time, config hash, split hash, seeds and thresholds.
-10. Only then run those seeds once with `experiment --unseal-test`.
-11. Run integrity analysis and publish successes and failures.
-
-## 6. Recommended next experiment
-
-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.
+2. Read `docs/ecp7-development-conclusion.md`; do not create ECP7-B30.
+3. Preserve every ECP-7 configuration and the still-sealed confirmatory split.
+4. Define a new ECP-8 question before implementing another architecture or loss.
+5. Create a fresh deterministic split and preregister its development gate.
+6. Add tests for every new invariant.
+7. Use only `smoke` and `develop` until one ECP-8 design passes development.
+8. Freeze at most one design, its UTC time, hashes, seeds and thresholds.
+9. Only then permit one confirmatory `experiment --unseal-test` execution.
+10. Run integrity analysis and publish successes and failures.
+
+## 6. Recommended next research phase
+
+ECP-7 development is closed after 29 sealed variants. Do not continue a
+residual schedule, collision coefficient, replay route or horizon search, and
+do not open the unused ECP-7 confirmatory split.
+
+Start ECP-8 with a separate preregistration that chooses exactly one new
+question. Plausible directions include learned compositional structure without
+fixed slots, variable-length coding efficiency, interactive negotiation, or
+transfer across altered synthetic worlds. These are different hypotheses:
+select one, define its channel and baselines, generate a fresh deterministic
+split, and register the development and confirmatory gates before training.
 
 ## 7. Definition of done for any contribution
 
 
@@ -36,6 +36,7 @@ this log.
 | 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 |
+| ECP7-B29-I | Intervention | B28 residual branch frozen at exact zero through step 30,000 | Position-aware MLP | valid negative; late activation immediately reduces capacity and worst-link validation |
 
 ## Batch 1 preregistration
 
@@ -2393,3 +2394,107 @@ 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.
+
+## Batch 29 preregistration
+
+Preregistered: July 18, 2026 at 18:47:04 UTC<br>
+Seed: `11`<br>
+Maximum population steps: `45,000`<br>
+Minimum selection steps: `15,000`<br>
+Early-stopping patience: `5,000` steps<br>
+Residual weight and bias through step 30,000: **exact zero and frozen**<br>
+Residual parameter gradients from step 30,001: **enabled**<br>
+Pre-existing sender and receiver gradients: **unchanged throughout**<br>
+Additional collision loss: **none**<br>
+Hard-meaning replay route: unchanged B25 sender-only warmup, then receiver-only catch-up<br>
+Raw configuration SHA-256: `4c4e32dc054eb4af400e04fccc5c312edea0e5cbfa9c39fbee6e2615d56258b9`<br>
+Effective configuration SHA-256: `6483d2cf84f2e7e1d0365e90aeefc99641fb9255c3617d8d3928623af5db3947`<br>
+Split-SHA-256: `4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd`<br>
+Test unsealed: **no**
+
+ECP7-B29-I inherits Batch 28's zero-RNG residual sender and every Batch 25
+training setting. It changes only when the two residual parameters may receive
+gradients. They remain non-trainable and exactly zero through step 30,000;
+because the branch consumes no RNG and contributes zero, all shared history
+fields through that boundary must match Batch 25 exactly. The residual weight
+and bias become trainable on step 30,001. All original sender parameters remain
+trainable throughout, and the established receiver-only hard-replay route is
+unchanged.
+
+The positive control is rerun. All existing validity and development gates
+remain unchanged. The late-capacity 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 gradual activation, alternative boundary,
+residual change, collision replay, new loss, route change, receiver change,
+optimizer, horizon, data, translator or seed may be tried inside Batch 29.
+If this final residual test fails, ECP-7 development closes without confirmatory
+test access.
+
+## Batch 29 results
+
+Positive-control run: `runs/ecp7-batch29-control-development/20260718T184951Z-ecp7-development`<br>
+Intervention run: `runs/ecp7-batch29-intervention-development/20260718T185111Z-ecp7-development`<br>
+Test unsealed: **no**
+
+| Metric | Positive control | ECP7-B29-I |
+|---|---:|---:|
+| Population train, mean | 100% | 84.8868% |
+| Population train, worst link | 100% | 82.2824% |
+| Population validation, mean | 100% | 84.7412% |
+| Population validation, worst link | 100% | 81.7383% |
+| Universal translator, validation | 100% | 85.0098% |
+| Exact sender-message agreement | 100% | 91.96% |
+| Unique messages per sender | 15,360 | 12,720–13,439 |
+| Collision meanings per sender | 0 | 1,921–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-B29-I passes the mean
+validation and translator thresholds but fails both train thresholds, sender
+injectivity and the added late-capacity/worst-link criterion. Its selected
+checkpoint occurs at step 31,000, only 1,000 steps after activation; patience
+stops the run at step 36,000. The joint gate fails and confirmatory access
+remains unauthorized.
+
+All 151 shared history records through step 30,000 match Batch 25 exactly.
+Every recorded residual-gradient flag is false through that boundary and true
+afterward. This validates the intended isolation: the branch is identically
+zero during the complete established shallow trajectory and genuinely trains
+only in the late phase.
+
+The intervention still regresses immediately. Relative to Batch 25, the step
+31,000 checkpoint loses 0.38 percentage points of mean train, 0.53 points of
+worst-link train, 0.50 points of mean validation, 0.98 points of worst-link
+validation and 0.12 points of translator validation. Validation falls further
+to 84.30% at the final step.
+
+Selected sender codebooks contain 13,163, 12,960, 12,720 and 13,439 unique
+messages, compared with Batch 25's 13,440, 12,960, 12,720 and 13,440. The late
+branch therefore removes 278 net occupied codes rather than adding capacity;
+the minimum remains 12,720. Selected residual weight norms of 2.36–3.33 and
+bias norms of 0.15–0.23 confirm that the branch moved materially from zero.
+
+The selected diagnostic finds 1,679 meanings failed by all links and 3,152
+failed by at least one link, with 11.00 mean failed links per erroneous
+meaning. Shared errors are essentially unchanged from Batch 25's 1,677, while
+any-link failures increase by 185. Population validation factor accuracies
+were `[99.88%, 99.89%, 98.41%, 86.56%]`; universal-translator factor
+accuracies were `[100%, 100%, 98.41%, 86.60%]`.
+
+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 29 decision and ECP-7 development closure
+
+ECP7-B29-I is a valid negative result. Late activation avoids Batch 28's
+catastrophic relearning failure, but even a residual branch introduced only
+after the shallow protocol is established immediately reduces code capacity
+and worst-link generalization. The representation hypothesis and its permitted
+schedule are rejected.
+
+No ECP-7 development variant passes the complete gate, so no `config/ecp7.yaml`
+is frozen and the ECP-7 confirmatory test remains sealed. Development closes
+after 29 transparently recorded batches. ECP-6 remains the latest confirmed
+result; future research must define a new ECP-8 question and fresh
+preregistration rather than continue tuning ECP-7.
@@ -0,0 +1,59 @@
+# ECP-7 Sealed Development Conclusion
+
+Status: **development closed; confirmatory test never accessed**<br>
+Closed: July 18, 2026<br>
+Completed variants: ECP7-B1-I through ECP7-B29-I
+
+## Conclusion
+
+ECP-7 asked whether the 14-bit, 16,384-meaning ECP-6 result would survive when
+the explicit one-factor-per-slot sender and receiver bias was weakened. No
+development variant passed the full preregistered gate. Therefore no frozen
+`config/ecp7.yaml` exists and no confirmatory ECP-7 experiment was run.
+
+The strongest weak-structure family used a bounded parallel sender and a
+position-aware MLP receiver. Batch 25 reached 85.26% train, 85.24% validation,
+82.71% worst-link validation and 85.13% universal-translator validation. Batch
+26 reached the highest mean validation at 85.38%, but did not improve hard-code
+capacity. Every strong variant remained non-injective and below the 97% mean
+and 95% worst-link train thresholds.
+
+## What the development series established
+
+1. A generic weak-structure sender-receiver pair can learn a compact,
+   translatable protocol far above chance without semantic symbol assignments.
+2. The position-aware receiver removes a major recurrent decoding bottleneck.
+3. Receiver-only catch-up can approach the mathematical ceiling of an existing
+   non-injective sender codebook, but cannot raise that ceiling.
+4. Sender-only and route-cycled ordinary-task replay redistribute shared errors
+   into link-specific errors instead of creating new codes.
+5. Direct relaxed collision-pair pressure reduces collision multiplicity and
+   increases entropy, but does not increase the number of occupied hard codes.
+6. Generic extra sender depth promotes training-relation memorization and
+   destroys compositional validation, even with exact identity and RNG-
+   equivalent initialization.
+7. Activating that residual capacity only after the successful shallow
+   trajectory still reduces code capacity and worst-link validation.
+
+## Scientific boundary
+
+ECP-7 is a negative development result, not a failed confirmatory experiment.
+The sealed test contains no published metric because it was never opened. This
+prevents repeated development choices from leaking into confirmatory evidence.
+
+ECP-6 remains the latest confirmed result: its fully factorized architecture
+learns a lossless, transferable and information-theoretically minimal protocol
+inside the synthetic product world. ECP-7 shows that this result does not yet
+survive the tested weakening of that architectural bias.
+
+## Next research phase
+
+Do not add ECP7-B30. A future ECP-8 must start with a new question and fresh
+preregistration. It should explicitly choose whether to study learned
+compositional structure, variable-length efficiency, interactive negotiation,
+or transfer across altered worlds. Those are different hypotheses and must not
+be combined in one development batch.
+
+Full per-batch preregistrations, metrics, decisions and artifact identities are
+in [`development-log-ecp7.md`](development-log-ecp7.md), with compact manifests
+under [`../evidence/ecp7-development/`](../evidence/ecp7-development/).