@@ -26,12 +26,11 @@ 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 three sealed batches are valid
-negative results. A generic sender collapsed to 130–139 messages, soft
-utilization reduced this to 85–104, and straight-through hard utilization
-improved it to 585–972 messages and 1.92% validation. The ECP-6 positive
-controls remained perfect. The direction is informative but still far below
-the development gate, so the ECP-7 confirmatory test remains sealed. See
+one-factor-per-slot architecture. Its first four 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
 [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md).
 
 ## Build on this work
@@ -75,6 +74,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`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.
+- [`config/ecp7-b4-development.yaml`](config/ecp7-b4-development.yaml) — direct joint-message collision pressure on top of Batch 3.
 - [`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 direct joint-message collision development
+  arm: straight_through_joint_collision
+  objective: >-
+    Test whether directly penalizing complete straight-through message
+    collisions between distinct inputs closes the higher-order utilization gap
+    left by marginal entropy and pairwise slot independence.
+
+training:
+  joint_message_collision:
+    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: 54 passing tests and split sizes `14336/1024/1024`.
+Expected baseline: 58 passing tests and split sizes `14336/1024/1024`.
 
 ## 4. Reproduce ECP-6
 
@@ -71,17 +71,19 @@ 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 3
+Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 4
 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. All paired ECP-6 positive controls
-stayed perfect. The confirmatory ECP-7 test is still sealed.
+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.
 
 Continue with this sequence:
 
 1. Read `docs/research-design-ecp7.md` and `docs/development-log-ecp7.md`.
-2. Define exactly one ECP7-B4 intervention and its failure criterion.
+2. Define exactly one ECP7-B5 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.
@@ -94,21 +96,22 @@ Continue with this sequence:
 
 ## 6. Recommended next experiment
 
-Batch 3 partly closed the soft-to-hard gap, but marginal balance and pairwise
-independence still allowed many complete-message collisions. The most
-informative next step is one direct joint-collision penalty. A clean ECP7-B4
-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. 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:
 
 - keep the same world and bit budget;
 - keep the joint autoregressive sender and generic isolated receiver;
-- retain the full Batch 3 objective and add one loss equal to the average
-  number of other distinct inputs with the same straight-through full message;
+- return to Batch 3 and add one straight-through loss that aligns sender
+  symbols for the same input 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 combine this with architectural resizing, changes to the existing loss
-weight, longer training, variable-length messages or negotiation. That would
-make any change from Batch 3 uninterpretable.
+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.
 
 ## 7. Definition of done for any contribution
 
 
@@ -11,6 +11,7 @@ this log.
 | ECP7-B1-I | Intervention | Joint-context bounded autoregressive | Generic sequence encoder | completed; gate failed |
 | ECP7-B2-I | Intervention | B1 sender plus factor-agnostic code utilization | Generic sequence encoder | completed; gate failed |
 | ECP7-B3-I | Intervention | B2 loss on straight-through hard messages | Generic sequence encoder | completed; gate failed |
+| ECP7-B4-I | Intervention | B3 plus direct full-message collision loss | Generic sequence encoder | completed; gate failed |
 
 No other ECP-7 variant has been trained.
 
@@ -207,3 +208,63 @@ confirmatory split remains sealed and no frozen ECP-7 configuration is created.
 A future ECP7-B4 may add one direct straight-through full-message collision
 penalty while retaining all Batch 3 settings. This targets joint collisions
 without assigning semantic factors to slots.
+
+## Batch 4 preregistration
+
+Date: July 18, 2026<br>
+Seed: `11`<br>
+Maximum population steps: `5,000`<br>
+Split-SHA-256: `4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd`<br>
+Test unsealed: **no**
+
+ECP7-B4-I retains all Batch 3 settings and adds one factor-agnostic loss: the
+average number of distinct minibatch inputs sharing the same complete
+straight-through message. Its exact formula, weight and warmup are recorded in
+`docs/research-design-ecp7.md`. The unchanged positive control is rerun. Smoke
+cannot authorize tuning.
+
+## Batch 4 results
+
+Positive-control run: `runs/ecp7-batch4-control-development/20260718T111008Z-ecp7-development`<br>
+Intervention run: `runs/ecp7-batch4-intervention-development/20260718T111141Z-ecp7-development`<br>
+Test unsealed: **no**
+
+| Metric | Positive control | ECP7-B4-I |
+|---|---:|---:|
+| Population train, mean | 100% | 0.3204% |
+| Population train, worst link | 100% | 0.2860% |
+| Population validation, mean | 100% | 0.4211% |
+| Population validation, worst link | 100% | 0.2930% |
+| Universal translator, validation | 100% | 0.6104% |
+| Unique messages per sender | 15,360 | 426–579 |
+| Collision meanings per sender | 0 | 14,781–14,934 |
+| Message entropy | 13.91 bits | 7.46–7.84 bits |
+| Development gate | pass | **fail** |
+
+The positive control again validated the batch at 100%. ECP7-B4-I failed every
+performance and injectivity gate and regressed relative to Batch 3.
+
+At the selected step 800 checkpoint, the average number of distinct colliding
+partners in the current minibatch was `0.03125`, while the retained hard
+utilization loss was `-0.7213`. Despite that low local collision count, global
+evaluation found only 426–579 messages across 15,360 accessible meanings. The
+minibatch signal was therefore too sparse and local to represent global
+codebook occupancy.
+
+Population validation dropped from Batch 3's 1.9226% to 0.4211%; message entropy
+dropped from 8.20–8.73 to 7.46–7.84 bits. Factor accuracies were approximately
+`[6.48%, 6.41%, 92.13%, 83.79%]`, so the added loss also disrupted the two
+factors previously learned almost exactly. Changing its weight after seeing
+this outcome is not permitted inside Batch 4.
+
+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 4 decision
+
+ECP7-B4-I is recorded as a negative development result and is not retained. The
+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.
@@ -199,3 +199,41 @@ unchanged. B3 must pass population, validation, translator, injectivity, channel
 and sealed-test checks together. A failure remains a development result and
 does not authorize confirmatory test access. No alternative estimator, weight
 or training schedule may be tried inside Batch 3.
+
+## Batch 4 preregistration — Direct joint-message collisions
+
+Status: **preregistered for sealed development**<br>
+Preregistered: July 18, 2026<br>
+Configuration: `config/ecp7-b4-development.yaml`<br>
+Raw configuration SHA-256: `6229c5cd13c796a9ce297b9c38cc2ff1a2090a2a22a5678ec7afe38aa0bd6955`<br>
+Effective configuration SHA-256: `4cffdb040ba358d7416e0643595c4e11fadc0fdffd5c0120761c4890a8c3f10e`
+
+Batch 3 improved marginal hard utilization but retained thousands of complete
+message collisions. Batch 4 asks whether directly penalizing those joint
+collisions produces an injective and compositional code without a semantic
+factor-to-slot binding.
+
+For every sender and minibatch, the new loss is the average number of other
+distinct inputs with the same complete straight-through message:
+
+`L_joint = (1/B) × sum_i sum_j!=i 1[x_i != x_j] × product_s <m_i,s, m_j,s>`
+
+Because the forward messages are one-hot, the slot dot product is one exactly
+when both symbols match, and the product is one exactly when the full messages
+match. Identical sampled inputs are excluded; no factor label, factor identity
+or desired code is provided. Straight-through gradients flow back through the
+hard messages.
+
+The joint-collision weight is fixed at `1.0` with a 400-step linear warmup. This
+is the only Batch 4 addition. The complete Batch 3 utilization objective,
+architecture, task loss, population, split, 14-bit channel, 5,000-step limit,
+early stopping and translator remain unchanged.
+
+The batch contains exactly two seed-11 runs:
+
+1. the unchanged ECP-6 positive control;
+2. ECP7-B4-I with the added direct joint-collision loss.
+
+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.
@@ -24,6 +24,11 @@ It remained below the gate but improved to 585–972 hard messages, 8.20–8.73
 bits of entropy and 1.92% validation. Exact identities and hashes are in
 `batch3-manifest.json`.
 
+Batch 4 added direct minibatch full-message collision pressure. It regressed to
+426–579 messages and 0.42% validation, showing that the sparse local signal was
+not a useful proxy for global codebook occupancy. Exact identities and hashes
+are in `batch4-manifest.json`.
+
 Reproduce the development arms with:
 
 ```bash
 
@@ -0,0 +1,40 @@
+{
+  "batch": "ECP7-B4",
+  "confirmatory_test_unsealed": false,
+  "control": {
+    "artifact_hashes": {
+      "effective_config.yaml": "4bfb976293f117d3ae35f790e4fd6371628be95d91febb334bc275dc5d6b66d4",
+      "posthoc-analysis.json": "4c028786125509cb33a081662d12c28743cc212d13161a2360948c82a46e4ec1",
+      "seed-11/metrics.json": "7af4742b93a1a68dd0603e5647cd7c33161a41af24a5e40deb95b7fb997efb04",
+      "summary.json": "2aa1a8fcf8d791a6fe4ef90f669b0564e6251cfd800476b178f63c464d9053fe"
+    },
+    "development_gate_passed": true,
+    "population_train_mean_exact_match": 1.0,
+    "population_validation_mean_exact_match": 1.0,
+    "run_id": "20260718T111008Z-ecp7-development",
+    "universal_translator_validation_exact_match": 1.0,
+    "unique_messages_per_sender": [15360, 15360, 15360, 15360]
+  },
+  "intervention": {
+    "artifact_hashes": {
+      "effective_config.yaml": "fd98dbb08a8cf11bd6c5e6d05f24c5950f48f11cec2e39024e901abd67bd9c9f",
+      "posthoc-analysis.json": "67fbb886d49e328c0643990b7b5d013c2fcb2831a4cdee0e0645a6082f7adb0f",
+      "seed-11/metrics.json": "f280df0ab86a0ba7555b6384bd370e3765f419d39f66f71c0a8a76704c79b297",
+      "summary.json": "1539a99f35f80467eafb5e1c7e90169c7724c862de7f9a45ced2e467b10f1e6a"
+    },
+    "best_code_utilization_loss": -0.7212955355644226,
+    "best_joint_message_collision_loss": 0.03125,
+    "best_step": 800,
+    "development_gate_passed": false,
+    "message_entropy_bits_per_sender": [7.514687306501297, 7.837134515331, 7.501597202083582, 7.462425878518177],
+    "population_train_mean_exact_match": 0.003204345703125,
+    "population_validation_factor_accuracy": [0.06475830078125, 0.06414794921875, 0.9212646484375, 0.837890625],
+    "population_validation_mean_exact_match": 0.00421142578125,
+    "run_id": "20260718T111141Z-ecp7-development",
+    "universal_translator_validation_exact_match": 0.006103515625,
+    "unique_messages_per_sender": [449, 579, 498, 426]
+  },
+  "seed": 11,
+  "split_artifact_sha256": "676195997ee0c77d5c9565bae045dbb938b432a2e4e74b666233b0a41f924718",
+  "split_sha256": "4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd"
+}
@@ -144,6 +144,13 @@ def validate_config(config: dict[str, Any]) -> None:
                 "Code-utilization message_source must be relaxed or straight_through."
             )
 
+    joint_collision = training.get("joint_message_collision", {})
+    if joint_collision.get("enabled", False):
+        if joint_collision.get("weight", -1) < 0:
+            raise ConfigError("Joint-collision weight cannot be negative.")
+        if joint_collision.get("warmup_steps", 0) < 1:
+            raise ConfigError("Joint-collision warmup must be positive.")
+
 
 def file_sha256(path: str | Path) -> str:
     digest = hashlib.sha256()
 
@@ -203,6 +203,12 @@ def train_population_system(
             raise ValueError(
                 "Code-utilization message source must be relaxed or straight_through."
             )
+    joint_collision_config = training.get("joint_message_collision", {})
+    joint_collision_enabled = bool(joint_collision_config.get("enabled", False))
+    if joint_collision_enabled and float(
+        joint_collision_config.get("weight", 0.0)
+    ) < 0:
+        raise ValueError("Joint-collision weight cannot be negative.")
     if population_config["pairing"] != "all_senders_all_receivers":
         raise ValueError(
             "Population training supports all_senders_all_receivers only."
@@ -341,12 +347,28 @@ def train_population_system(
             utilization_weight = float(utilization_config["weight"]) * min(
                 step / utilization_warmup, 1.0
             )
+        joint_collision_loss = torch.zeros((), device=device)
+        joint_collision_weight = 0.0
+        if joint_collision_enabled:
+            joint_collision_loss = torch.stack(
+                [
+                    straight_through_joint_collision_loss(message, batch)
+                    for message in messages
+                ]
+            ).mean()
+            joint_collision_warmup = max(
+                int(joint_collision_config.get("warmup_steps", 1)), 1
+            )
+            joint_collision_weight = float(
+                joint_collision_config["weight"]
+            ) * min(step / joint_collision_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
         )
         optimizer.zero_grad(set_to_none=True)
         loss.backward()
@@ -379,6 +401,10 @@ def train_population_system(
                 "atom_code_consensus_weight": float(atom_consensus_weight),
                 "code_utilization_loss": float(utilization_loss.detach().cpu()),
                 "code_utilization_weight": float(utilization_weight),
+                "joint_message_collision_loss": float(
+                    joint_collision_loss.detach().cpu()
+                ),
+                "joint_message_collision_weight": float(joint_collision_weight),
                 "temperature": float(temperature),
                 "train_mean_exact": train_metrics["mean_exact_match"],
                 "train_worst_pair_exact": train_metrics["worst_pair_exact_match"],
@@ -594,6 +620,23 @@ def factor_agnostic_code_utilization_loss(
     return determinism - utilization + independence_weight * independence
 
 
+def straight_through_joint_collision_loss(
+    message_distributions: Tensor, meanings: Tensor
+) -> Tensor:
+    """Average colliding distinct inputs per item in a straight-through batch."""
+    if message_distributions.ndim != 3:
+        raise ValueError("Joint-collision messages must have shape [batch,slots,vocab].")
+    if meanings.ndim != 2 or meanings.shape[0] != message_distributions.shape[0]:
+        raise ValueError("Joint-collision meanings must match the message batch.")
+    per_slot_agreement = torch.einsum(
+        "bsv,csv->bcs", message_distributions, message_distributions
+    )
+    full_message_agreement = per_slot_agreement.prod(dim=-1)
+    same_input = meanings[:, None, :].eq(meanings[None, :, :]).all(dim=-1)
+    distinct_input = (~same_input).to(full_message_agreement.dtype)
+    return (full_message_agreement * distinct_input).sum() / meanings.shape[0]
+
+
 def build_algebraic_quadruples(
     train_meanings: tuple[Meaning, ...],
     *,
 
@@ -58,3 +58,8 @@ def ecp7_b2_config():
 @pytest.fixture(scope="session")
 def ecp7_b3_config():
     return load_config(PROJECT_ROOT / "config" / "ecp7-b3-development.yaml")
+
+
+@pytest.fixture(scope="session")
+def ecp7_b4_config():
+    return load_config(PROJECT_ROOT / "config" / "ecp7-b4-development.yaml")