fix: signal descriptor degeneracy -- correct emission_activity and receptor_sensitivity

Two bugs caused all 300 rollouts to land in 1 archive cell.

flowlenia.py
  Add step_with_signal_diagnostics() alongside step(). Returns the same
  (new_A, new_signal) result plus two diagnostic scalars computed as
  natural byproducts of the signal physics block:
    emission_activity:    mean(G_pos * effective_rate) over the grid --
                          actual per-cell emission this step, correctly
                          derived from the growth field (not the mass field).
    receptor_sensitivity: mean(|receptor_response|) over the grid --
                          spatially-resolved reception after convolution,
                          not the spatially-averaged approximation.
  Zero code duplication, zero performance cost for non-diagnostic paths.

rollout.py
  Signal rollout loop calls step_with_signal_diagnostics() instead of
  step() when capturing descriptor histories. Removes the two broken
  approximations:
    Bug 1: emission was computed as mean(mass_field) * emission_rate.
      mass_field is always positive and nearly constant for viable
      solitons -- so every creature scored identically on emission_activity.
    Bug 2: reception was computed as |dot(mean_signal, receptor_profile)|
      where mean_signal is the spatially-averaged signal field. This is
      near-zero for almost all of a solo rollout (signal starts tiny,
      builds slowly) -- so every creature scored ~0 on receptor_sensitivity.

descriptors.py
  Normalizers recalibrated against corrected measurements:
    emission_activity:    0.05 → 0.001
      mean(G_pos * rate) spans ~0.00005-0.003 in practice (G_pos averaged
      over grid ~0.0-0.1; rate in [0.001, 0.05]).
    receptor_sensitivity: 0.5  → 0.005
      mean|receptor_response| spans ~0.00001-0.003 (convolved signal
      builds from near-zero; spatial receptor response is small but real).

tests/search/test_descriptors.py
  Test input values updated to stay within the new normalizer ranges
  so scaling tests remain meaningful rather than clipping to 1.0.

422 passed, 0 errors, 0 warnings

Author: rkv0id

src/biota/search/descriptors.py

@@ -697,10 +697,10 @@ def compute_emission_activity(trace: RolloutTrace) -> float:
     if trace.signal_emission_history is None or len(trace.signal_emission_history) == 0:
         return 0.0
     mean_activity = float(trace.signal_emission_history.mean())
-    # Normalize: emission activity is bounded by emission_rate * G_peak.
-    # G_peak ~ 1.0, emission_rate max = 0.05, so peak activity ~ 0.05.
-    # Use 0.05 as normalizer to put typical values in [0, 1].
-    return float(np.clip(mean_activity / 0.05, 0.0, 1.0))
+    # Normalizer calibrated to mean(G_pos * rate): G_pos averaged over grid
+    # is typically 0.0-0.1; rate in [0.001, 0.05]. So mean(G_pos * rate)
+    # spans ~0.00005-0.003 in practice. 0.001 gives good spread.
+    return float(np.clip(mean_activity / 0.001, 0.0, 1.0))
 
 
 def compute_receptor_sensitivity(trace: RolloutTrace) -> float:
@@ -712,12 +712,14 @@ def compute_receptor_sensitivity(trace: RolloutTrace) -> float:
     produced strong growth modulation. Low = chemical mismatch or inert.
 
     Returns 0.0 for non-signal rollouts.
-    Normalized against a typical peak of 0.5.
+    Normalizer calibrated to mean|receptor_response|: convolved signal builds
+    from near-zero over 800 steps; typical mean response 0.00001-0.003.
+    0.005 gives good spread across the [0,1] range.
     """
     if trace.signal_reception_history is None or len(trace.signal_reception_history) == 0:
         return 0.0
     mean_response = float(np.abs(trace.signal_reception_history).mean())
-    return float(np.clip(mean_response / 0.5, 0.0, 1.0))
+    return float(np.clip(mean_response / 0.005, 0.0, 1.0))
 
 
 def compute_signal_retention(trace: RolloutTrace) -> float:

src/biota/search/rollout.py

@@ -308,26 +308,19 @@ def rollout(
         com_x_np[step] = com_x
         bbox_np[step] = bbox
         gyradius_np[step] = gyr
-        if (
-            emission_np is not None
-            and signal is not None
-            and sim_params.receptor_profile is not None
-        ):
-            # Emission activity: mean positive-growth signal emission this step.
-            g_pos_mean = float(state[:, :, 0].clamp(min=0.0).mean().item())
-            rate = sim_params.emission_rate if sim_params.emission_rate is not None else 0.0
-            emission_np[step] = g_pos_mean * rate
-            # Reception: mean |dot(signal_sum, receptor)| as a scalar.
-            if reception_np is not None:
-                sig_mean = signal.mean(dim=(0, 1))  # (C,)
-                rec_resp = float((sig_mean * sim_params.receptor_profile).sum().abs().item())
-                reception_np[step] = rec_resp
         if step in frame_indices:
             thumb_buf.append(_downsample_frame(state, thumbnail_size))
         if step == midpoint_step:
             midpoint_state_np = state[:, :, 0].detach().cpu().numpy().astype(np.float32)
         if step < config.steps:
-            state, signal = fl.step(state, signal)
+            if is_signal_rollout and emission_np is not None and reception_np is not None:
+                # Use diagnostics variant to get accurate G_pos and receptor_response
+                # scalars from inside step() -- the only place where both are computed.
+                state, signal, emit_act, recep_sens = fl.step_with_signal_diagnostics(state, signal)
+                emission_np[step] = emit_act
+                reception_np[step] = recep_sens
+            else:
+                state, signal = fl.step(state, signal)
 
     final_mass = float(state.sum().item())
     final_signal_mass = float(signal.sum().item()) if signal is not None else 0.0

src/biota/sim/flowlenia.py

@@ -258,7 +258,93 @@ def step(
 
         return new_A2.unsqueeze(-1), new_signal
 
-    def step_batch(self, A: torch.Tensor) -> torch.Tensor:
+    def step_with_signal_diagnostics(
+        self, A: torch.Tensor, signal: torch.Tensor | None
+    ) -> tuple[torch.Tensor, torch.Tensor | None, float, float]:
+        """Like step(), but also returns per-step signal diagnostic scalars.
+
+        Used by the rollout loop to capture emission_activity and
+        receptor_sensitivity descriptor histories without re-running the sim.
+
+        Returns:
+            (new_A, new_signal, emission_activity, receptor_sensitivity)
+            emission_activity:    mean(G_pos * effective_rate) over the grid --
+                                  the actual per-cell emission scalar, averaged.
+                                  Proportional to how much signal was emitted this step.
+            receptor_sensitivity: mean(|receptor_response|) over the grid --
+                                  how strongly the creature responded to the convolved
+                                  signal field this step.
+            Both are 0.0 for non-signal creatures or when signal is None.
+        """
+        A2 = A[:, :, 0]
+
+        fA = torch.fft.fft2(A2)
+        U = torch.fft.ifft2(self._fK * fA.unsqueeze(0)).real
+        m = self.params.m.view(-1, 1, 1)
+        s = self.params.s.view(-1, 1, 1)
+        h = self.params.h.view(-1, 1, 1)
+        G = (torch.exp(-(((U - m) / s) ** 2) / 2.0) * 2.0 - 1.0) * h
+        U_sum = G.sum(dim=0)
+
+        emission_activity_scalar = 0.0
+        receptor_sensitivity_scalar = 0.0
+
+        if signal is not None and self.params.has_signal and self._fK_signal is not None:
+            assert self.params.emission_vector is not None
+            assert self.params.receptor_profile is not None
+
+            G_pos = U_sum.clamp(min=0.0)
+
+            sig_t = signal.permute(2, 0, 1)
+            fSig = torch.fft.fft2(sig_t)
+            convolved = torch.fft.ifft2(self._fK_signal * fSig).real
+            receptor_response = (convolved * self.params.receptor_profile.view(-1, 1, 1)).sum(dim=0)
+
+            # receptor_sensitivity: mean absolute reception response over the grid
+            receptor_sensitivity_scalar = float(receptor_response.abs().mean().item())
+
+            alpha_c = self.params.alpha_coupling if self.params.alpha_coupling is not None else 0.0
+            if alpha_c != 0.0:
+                growth_multiplier = (1.0 + alpha_c * receptor_response).clamp(min=0.0)
+                U_sum = U_sum * growth_multiplier
+                G_pos = U_sum.clamp(min=0.0)
+
+            base_rate = self.params.emission_rate if self.params.emission_rate is not None else 0.0
+            beta_m = self.params.beta_modulation if self.params.beta_modulation is not None else 0.0
+            if beta_m != 0.0:
+                received_mean = float(receptor_response.mean().item())
+                effective_rate = float(
+                    max(0.0, min(0.1, base_rate * (1.0 + beta_m * received_mean)))
+                )
+            else:
+                effective_rate = base_rate
+
+            # emission_activity: mean(G_pos * effective_rate) -- actual emission per cell
+            emission_activity_scalar = float((G_pos * effective_rate).mean().item())
+
+            emitted = G_pos * effective_rate
+            emitted = torch.minimum(emitted, A2.clamp(min=0.0))
+            emit_per_channel = emitted.unsqueeze(-1) * self.params.emission_vector
+            signal = signal + emit_per_channel
+            A2 = A2 - emitted
+
+        nabla_U = self._sobel(U_sum)
+        nabla_A = self._sobel(A2)
+        alpha = torch.clamp(A2**2, 0.0, 1.0)
+        F_flow = nabla_U * (1.0 - alpha) - nabla_A * alpha
+        new_A2 = self._reintegration(A2, F_flow)
+
+        if signal is not None and self.params.has_signal:
+            new_signal = signal * (1.0 - self._decay)
+        else:
+            new_signal = signal
+
+        return (
+            new_A2.unsqueeze(-1),
+            new_signal,
+            emission_activity_scalar,
+            receptor_sensitivity_scalar,
+        )
         """Vectorized step over a batch of states. Signal field not supported
         in batch mode (search rollouts don't use it; ecosystem uses single-step).
 

tests/search/test_descriptors.py

@@ -580,8 +580,8 @@ def test_emission_activity_zero_for_empty_history() -> None:
 
 
 def test_emission_activity_scales_with_emission() -> None:
-    low = _make_signal_trace(emission_history=np.full(TRACE_LEN, 0.005, dtype=np.float32))
-    high = _make_signal_trace(emission_history=np.full(TRACE_LEN, 0.04, dtype=np.float32))
+    low = _make_signal_trace(emission_history=np.full(TRACE_LEN, 0.0002, dtype=np.float32))
+    high = _make_signal_trace(emission_history=np.full(TRACE_LEN, 0.0008, dtype=np.float32))
     assert compute_emission_activity(low) < compute_emission_activity(high)
 
 
@@ -613,14 +613,14 @@ def test_receptor_sensitivity_zero_for_empty_history() -> None:
 
 
 def test_receptor_sensitivity_scales_with_response() -> None:
-    low = _make_signal_trace(reception_history=np.full(TRACE_LEN, 0.05, dtype=np.float32))
-    high = _make_signal_trace(reception_history=np.full(TRACE_LEN, 0.4, dtype=np.float32))
+    low = _make_signal_trace(reception_history=np.full(TRACE_LEN, 0.001, dtype=np.float32))
+    high = _make_signal_trace(reception_history=np.full(TRACE_LEN, 0.003, dtype=np.float32))
     assert compute_receptor_sensitivity(low) < compute_receptor_sensitivity(high)
 
 
 def test_receptor_sensitivity_in_unit_interval() -> None:
     trace = _make_signal_trace(
-        reception_history=np.random.default_rng(9).random(TRACE_LEN).astype(np.float32) * 0.3
+        reception_history=np.random.default_rng(9).random(TRACE_LEN).astype(np.float32) * 0.003
     )
     val = compute_receptor_sensitivity(trace)
     assert 0.0 <= val <= 1.0