@@ -26,11 +26,12 @@ 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 four sealed batches are valid
+one-factor-per-slot architecture. Its first five sealed batches are valid
 negative results. Straight-through hard utilization remains the best weakly
-structured variant at 585–972 messages and 1.92% validation. A direct minibatch
-collision penalty regressed to 426–579 messages and 0.42%. The ECP-6 positive
-controls remained perfect. The ECP-7 confirmatory test remains sealed. See
+structured variant at 585–972 messages and 1.92% validation. Direct collision
+pressure regressed, while sender consensus raised exact agreement to 44.02% but
+collapsed the code to 169–231 messages. The ECP-6 positive controls remained
+perfect. The ECP-7 confirmatory test remains sealed. See
 [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md).
 
 ## Build on this work
@@ -75,6 +76,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`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.
 - [`config/ecp7-b4-development.yaml`](config/ecp7-b4-development.yaml) — direct joint-message collision pressure on top of Batch 3.
+- [`config/ecp7-b5-development.yaml`](config/ecp7-b5-development.yaml) — straight-through sender consensus on the Batch 3 base.
 - [`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,15 @@
+extends: ecp7-b3-development.yaml
+
+experiment:
+  title: ECP-7 straight-through sender-consensus development
+  arm: straight_through_sender_consensus
+  objective: >-
+    Test whether factor-agnostic pairwise agreement between independent senders
+    creates one shared hard-message convention while the Batch 3 utilization
+    objective preserves codebook diversity.
+
+training:
+  sender_message_consensus:
+    enabled: true
+    weight: 1.0
+    warmup_steps: 400
@@ -41,7 +41,7 @@ python3.12 -m venv .venv
 .venv/bin/ecp6 --config config/ecp6.yaml validate
 ```
 
-Expected baseline: 58 passing tests and split sizes `14336/1024/1024`.
+Expected baseline: 62 passing tests and split sizes `14336/1024/1024`.
 
 ## 4. Reproduce ECP-6
 
@@ -71,19 +71,21 @@ 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 4
+Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 5
 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,
 but still reached only 1.92% validation. ECP7-B4-I added direct minibatch
-collision pressure and regressed to 426–579 messages and 0.42% validation. All
-paired ECP-6 positive controls stayed perfect. The confirmatory ECP-7 test is
-still sealed.
+collision pressure and regressed to 426–579 messages and 0.42% validation.
+ECP7-B5-I raised exact inter-sender agreement from 2.47% to 44.02%, but did so
+through a shared collapse to 169–231 messages and 0.48% validation. All paired
+ECP-6 positive controls stayed perfect. The confirmatory ECP-7 test is still
+sealed.
 
 Continue with this sequence:
 
 1. Read `docs/research-design-ecp7.md` and `docs/development-log-ecp7.md`.
-2. Define exactly one ECP7-B5 intervention and its failure criterion.
+2. Define exactly one ECP7-B6 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.
@@ -96,22 +98,24 @@ Continue with this sequence:
 
 ## 6. Recommended next experiment
 
-Batch 3 remains the strongest weak-structure variant; Batch 4 showed that sparse
-minibatch collision pressure is not a useful proxy for global occupancy. The
-four B3 senders also agreed on only 2.47% of complete messages. The most
-informative next step is one factor-agnostic sender-consensus loss. A clean
-ECP7-B5 progression is:
+Batch 3 remains the strongest weak-structure variant. Batch 4 showed that sparse
+minibatch collision pressure is not a useful proxy for global occupancy, while
+Batch 5 showed that agreement pressure creates a shared collapse. Across these
+batches, color and especially shape remain weak while size and texture are much
+easier. The most informative next step is one minimax factor-reconstruction
+objective. A clean ECP7-B6 progression is:
 
 - keep the same world and bit budget;
 - keep the joint autoregressive sender and generic isolated receiver;
-- return to Batch 3 and add one straight-through loss that aligns sender
-  symbols for the same input without assigning factors to slots;
+- return to Batch 3 and add one fixed objective that emphasizes the currently
+  worst factor-level cross-entropy without assigning factors to slots;
 - measure injectivity, validation composition and new-reader induction;
 - rerun the ECP-6 architecture as the frozen positive control.
 
-Do not retain the Batch 4 collision term or combine consensus with architectural
-resizing, longer training, variable-length messages or negotiation. That would
-make the sender-consensus effect uninterpretable.
+Do not retain the Batch 4 collision or Batch 5 consensus terms, and do not
+combine factor balancing with architectural resizing, longer training,
+variable-length messages or negotiation. That would make its effect
+uninterpretable.
 
 ## 7. Definition of done for any contribution
 
 
@@ -268,3 +268,74 @@ confirmatory split remains sealed. The strongest weak-structure variant remains
 ECP7-B3-I. A future ECP7-B5 may add one straight-through sender-consensus loss
 to B3, testing whether a shared factor-agnostic convention helps receivers
 without restoring semantic slot assignments.
+
+## Batch 5 preregistration
+
+Date: July 18, 2026<br>
+Seed: `11`<br>
+Maximum population steps: `5,000`<br>
+Split-SHA-256: `4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd`<br>
+Test unsealed: **no**
+
+ECP7-B5-I returns to the Batch 3 configuration and adds exactly one
+factor-agnostic loss: mean straight-through symbol disagreement between every
+sender pair on the same minibatch. Its fixed formula, weight and warmup are
+recorded in `docs/research-design-ecp7.md`. The Batch 4 collision loss is not
+retained. The unchanged positive control is rerun. Smoke is mechanical only
+and cannot authorize tuning.
+
+## Batch 5 results
+
+Positive-control run: `runs/ecp7-batch5-control-development/20260718T112234Z-ecp7-development`<br>
+Intervention run: `runs/ecp7-batch5-intervention-development/20260718T112234Z-ecp7-development`<br>
+Test unsealed: **no**
+
+| Metric | Positive control | ECP7-B5-I |
+|---|---:|---:|
+| Population train, mean | 100% | 0.1818% |
+| Population train, worst link | 100% | 0.1256% |
+| Population validation, mean | 100% | 0.4761% |
+| Population validation, worst link | 100% | 0.1953% |
+| Universal translator, validation | 100% | 0.5859% |
+| Exact sender-message agreement | 100% | 44.02% |
+| Unique messages per sender | 15,360 | 169–231 |
+| Collision meanings per sender | 0 | 15,129–15,191 |
+| Message entropy | 13.91 bits | 6.02–6.13 bits |
+| Development gate | pass | **fail** |
+
+The positive control again validated the batch at 100%. ECP7-B5-I failed the
+population, validation, translator and injectivity gates. It stopped at step
+2,000 under the unchanged early-stopping rule, with step 400 selected.
+
+The intervention answered its narrow question: exact complete-message
+agreement between sender pairs increased from Batch 3's 2.47% to 44.02%.
+However, the shared convention was mostly a shared collapse. Unique messages
+fell from Batch 3's 585–972 to 169–231 and entropy fell from 8.20–8.73 to
+6.02–6.13 bits. At the selected checkpoint, sender-consensus loss was `0.2673`
+and hard-utilization loss was only `-0.5350`, compared with Batch 3's selected
+hard-utilization value of approximately `-0.7075`.
+
+Population validation factor accuracies were approximately
+`[6.43%, 6.31%, 64.42%, 78.00%]`. Consensus therefore did not recover color or
+shape and also weakened size and texture. Population validation fell from
+Batch 3's 1.9226% to 0.4761%; translator validation fell from 2.2705% to
+0.5859%.
+
+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 5 decision
+
+ECP7-B5-I is recorded as a negative development result and is not retained. It
+shows that inter-sender agreement is not sufficient: without a stronger
+semantic pressure, independent senders can agree by discarding distinctions.
+The confirmatory split remains sealed and ECP7-B3-I remains the strongest
+weak-structure variant.
+
+Across B3–B5, color and especially shape remain the persistent bottleneck while
+size and texture are easier to learn. A future ECP7-B6 may return to B3 and add
+one minimax factor-reconstruction objective that emphasizes the currently
+worst decoded factor without assigning any factor to a channel slot. It must
+not retain the rejected B4 or B5 losses or change the architecture at the same
+time.
@@ -237,3 +237,45 @@ The batch contains exactly two seed-11 runs:
 All existing validity and development gates remain unchanged. Failure is
 recorded without confirmatory test access. No alternative collision weight,
 batch size, architecture or duration may be tried inside Batch 4.
+
+## Batch 5 preregistration — Straight-through sender consensus
+
+Status: **preregistered for sealed development**<br>
+Preregistered: July 18, 2026<br>
+Configuration: `config/ecp7-b5-development.yaml`<br>
+Raw configuration SHA-256: `3333e3e150e242b0984e79a2923ffe94d68cee7d004ae51f4914097917503db7`<br>
+Effective configuration SHA-256: `4c2648efa2719d1cd3e0bdf96a2cbea21ea697280b74bbce82ba45371bbc0ed9`
+
+Batch 4 regressed relative to Batch 3, so Batch 5 returns to the stronger
+ECP7-B3-I base and does not retain the joint-collision loss. Batch 3's four
+senders used substantially more of the hard code space than earlier batches,
+but their complete-message agreement on the accessible meanings was only
+approximately 2.47%. Batch 5 asks whether one shared factor-agnostic convention
+helps generic receivers learn the protocol.
+
+For the same training minibatch, the new objective compares each unordered
+pair of senders. It averages their straight-through one-hot symbol disagreement
+over inputs and message slots, then averages over all sender pairs:
+
+`L_sender = mean_(a<b,x,s) [1 - <m_a(x,s), m_b(x,s)>]`
+
+The forward value is zero when two senders emit the same hard symbol and one
+when they differ. Gradients flow through the straight-through Gumbel estimator.
+The objective receives no factor labels, factor identities, target slots,
+desired symbols or privileged codebook. Per-sender hard utilization from Batch
+3 remains active to oppose agreement through collapse.
+
+The sender-consensus weight is fixed at `1.0` with a 400-step linear warmup.
+This is the only Batch 5 addition. Architecture, task loss, Batch 3 hard
+utilization, population, split, 14-bit channel, 5,000-step limit, early
+stopping and translator remain unchanged. The rejected Batch 4 collision loss
+is absent.
+
+The batch contains exactly two seed-11 runs:
+
+1. the unchanged ECP-6 positive control;
+2. ECP7-B5-I with straight-through sender consensus on the Batch 3 base.
+
+All existing validity and development gates remain unchanged. Failure is
+recorded without confirmatory test access. No alternative consensus weight,
+warmup, reduction, architecture or duration may be tried inside Batch 5.
@@ -29,6 +29,11 @@ Batch 4 added direct minibatch full-message collision pressure. It regressed to
 not a useful proxy for global codebook occupancy. Exact identities and hashes
 are in `batch4-manifest.json`.
 
+Batch 5 aligned straight-through symbols across independent senders on the
+Batch 3 base. Exact complete-message agreement rose from 2.47% to 44.02%, but
+the shared protocol collapsed to 169–231 messages and 0.48% validation. Exact
+identities and hashes are in `batch5-manifest.json`.
+
 Reproduce the development arms with:
 
 ```bash
 
@@ -0,0 +1,41 @@
+{
+  "batch": "ECP7-B5",
+  "confirmatory_test_unsealed": false,
+  "control": {
+    "artifact_hashes": {
+      "effective_config.yaml": "4bfb976293f117d3ae35f790e4fd6371628be95d91febb334bc275dc5d6b66d4",
+      "posthoc-analysis.json": "c1584664fb80be9aead8cc0f475f25f7406aaab127a647e0e56ab6e0df95bfb3",
+      "seed-11/metrics.json": "2dc9534c05f386328a12e4a332dc1efbb4f73eebbb3485ae31494de88fde5bed",
+      "summary.json": "b0bbf9350b501962f340ea7c001d18fe6c7b00dea1dc154e0b5e4bc43b1884fb"
+    },
+    "development_gate_passed": true,
+    "population_train_mean_exact_match": 1.0,
+    "population_validation_mean_exact_match": 1.0,
+    "run_id": "20260718T112234Z-ecp7-development",
+    "universal_translator_validation_exact_match": 1.0,
+    "unique_messages_per_sender": [15360, 15360, 15360, 15360]
+  },
+  "intervention": {
+    "artifact_hashes": {
+      "effective_config.yaml": "fa92c6924d3809c85f1517037deadc55db133ce403be00267fc0adb7f141586c",
+      "posthoc-analysis.json": "27fbe964c56e74309bbf42e6e795ba38091615f1575c9966b7f6ae90b7241d8a",
+      "seed-11/metrics.json": "357d08228f47614f3c97d84cff414a18fccc23fd28b5fadbf2b8e175094c0504",
+      "summary.json": "0b3435a7c3d8712c252feba1cf46a19cafdcd328b4e9db8fc692062f35d6b6a9"
+    },
+    "best_code_utilization_loss": -0.5349538326263428,
+    "best_sender_message_consensus_loss": 0.2672525942325592,
+    "best_step": 400,
+    "development_gate_passed": false,
+    "exact_sender_message_agreement": 0.44023437499999996,
+    "message_entropy_bits_per_sender": [6.125398440530093, 6.019520019497614, 6.091599411068266, 6.106033809745002],
+    "population_train_mean_exact_match": 0.0018179757254464285,
+    "population_validation_factor_accuracy": [0.06427001953125, 0.0631103515625, 0.6441650390625, 0.77996826171875],
+    "population_validation_mean_exact_match": 0.0047607421875,
+    "run_id": "20260718T112234Z-ecp7-development",
+    "universal_translator_validation_exact_match": 0.005859375,
+    "unique_messages_per_sender": [194, 199, 231, 169]
+  },
+  "seed": 11,
+  "split_artifact_sha256": "676195997ee0c77d5c9565bae045dbb938b432a2e4e74b666233b0a41f924718",
+  "split_sha256": "4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd"
+}
@@ -151,6 +151,13 @@ def validate_config(config: dict[str, Any]) -> None:
         if joint_collision.get("warmup_steps", 0) < 1:
             raise ConfigError("Joint-collision warmup must be positive.")
 
+    sender_consensus = training.get("sender_message_consensus", {})
+    if sender_consensus.get("enabled", False):
+        if sender_consensus.get("weight", -1) < 0:
+            raise ConfigError("Sender-message consensus weight cannot be negative.")
+        if sender_consensus.get("warmup_steps", 0) < 1:
+            raise ConfigError("Sender-message consensus warmup must be positive.")
+
 
 def file_sha256(path: str | Path) -> str:
     digest = hashlib.sha256()
 
@@ -209,6 +209,12 @@ def train_population_system(
         joint_collision_config.get("weight", 0.0)
     ) < 0:
         raise ValueError("Joint-collision weight cannot be negative.")
+    sender_consensus_config = training.get("sender_message_consensus", {})
+    sender_consensus_enabled = bool(sender_consensus_config.get("enabled", False))
+    if sender_consensus_enabled and float(
+        sender_consensus_config.get("weight", 0.0)
+    ) < 0:
+        raise ValueError("Sender-message consensus weight cannot be negative.")
     if population_config["pairing"] != "all_senders_all_receivers":
         raise ValueError(
             "Population training supports all_senders_all_receivers only."
@@ -362,13 +368,24 @@ def train_population_system(
             joint_collision_weight = float(
                 joint_collision_config["weight"]
             ) * min(step / joint_collision_warmup, 1.0)
+        sender_consensus_loss = torch.zeros((), device=device)
+        sender_consensus_weight = 0.0
+        if sender_consensus_enabled:
+            sender_consensus_loss = straight_through_sender_consensus_loss(messages)
+            sender_consensus_warmup = max(
+                int(sender_consensus_config.get("warmup_steps", 1)), 1
+            )
+            sender_consensus_weight = float(
+                sender_consensus_config["weight"]
+            ) * min(step / sender_consensus_warmup, 1.0)
         loss = (
             task_loss
             + consistency_weight * consistency_loss
             + slot_consensus_weight * slot_consensus_loss
             + atom_consensus_weight * atom_consensus_loss
             + utilization_weight * utilization_loss
             + joint_collision_weight * joint_collision_loss
+            + sender_consensus_weight * sender_consensus_loss
         )
         optimizer.zero_grad(set_to_none=True)
         loss.backward()
@@ -405,6 +422,12 @@ def train_population_system(
                     joint_collision_loss.detach().cpu()
                 ),
                 "joint_message_collision_weight": float(joint_collision_weight),
+                "sender_message_consensus_loss": float(
+                    sender_consensus_loss.detach().cpu()
+                ),
+                "sender_message_consensus_weight": float(
+                    sender_consensus_weight
+                ),
                 "temperature": float(temperature),
                 "train_mean_exact": train_metrics["mean_exact_match"],
                 "train_worst_pair_exact": train_metrics["worst_pair_exact_match"],
@@ -637,6 +660,30 @@ def straight_through_joint_collision_loss(
     return (full_message_agreement * distinct_input).sum() / meanings.shape[0]
 
 
+def straight_through_sender_consensus_loss(
+    message_distributions: list[Tensor],
+) -> Tensor:
+    """Align complete straight-through messages across independent senders."""
+    if len(message_distributions) < 2:
+        raise ValueError("Sender consensus requires at least two senders.")
+    reference_shape = message_distributions[0].shape
+    if len(reference_shape) != 3:
+        raise ValueError(
+            "Sender-consensus messages must have shape [batch,slots,vocab]."
+        )
+    if any(
+        message.shape != reference_shape for message in message_distributions[1:]
+    ):
+        raise ValueError("Sender-consensus messages must share one shape.")
+
+    pair_losses = []
+    for left_index, left in enumerate(message_distributions):
+        for right in message_distributions[left_index + 1 :]:
+            symbol_agreement = (left * right).sum(dim=-1)
+            pair_losses.append(1.0 - symbol_agreement.mean())
+    return torch.stack(pair_losses).mean()
+
+
 def build_algebraic_quadruples(
     train_meanings: tuple[Meaning, ...],
     *,
 
@@ -63,3 +63,8 @@ def ecp7_b3_config():
 @pytest.fixture(scope="session")
 def ecp7_b4_config():
     return load_config(PROJECT_ROOT / "config" / "ecp7-b4-development.yaml")
+
+
+@pytest.fixture(scope="session")
+def ecp7_b5_config():
+    return load_config(PROJECT_ROOT / "config" / "ecp7-b5-development.yaml")