lstar: do not skip trivial inputs when aggregate() serves block building

The fill-ci failures were caused by applying the aggregator-role
``1 raw + 0 children`` skip unconditionally inside ``aggregate()``.
The consensus-testing ``BlockSpec`` filler calls ``spec.aggregate(store)``
before ``build_block()`` to fold gossip sigs into
``latest_known_aggregated_payloads``. Many fork-choice fixture tests seed
single-validator attestations that way; skipping them broke head selection,
reorg depth, and the MAX_ATTESTATIONS_DATA rejection case.

Add ``skip_trivial_inputs: bool = True`` to ``aggregate()``:

- Interval-2 aggregator ticks (``tick_interval``) keep the default and skip
  trivial inputs — the intended #747 optimization.
- Block-building simulation passes ``skip_trivial_inputs=False`` so every
  gossip sig the proposer seeded is aggregated into known payloads before
  ``build_block()`` runs.

Verified locally: all 9 previously failing fill tests pass.

Author: ch4r10t33r

packages/testing/src/consensus_testing/test_types/block_spec.py

@@ -523,7 +523,7 @@ def build_signed_block_with_store(
         # Aggregation runs on a local clone: gossip pools mutate here, but the
         # caller's gossip-signature view must not be consumed by this simulated
         # build. Only the freshly aggregated Type-1 payloads propagate back.
-        aggregation_store, _ = spec.aggregate(store)
+        aggregation_store, _ = spec.aggregate(store, skip_trivial_inputs=False)
         merged_store = spec.accept_new_attestations(aggregation_store)
 
         # Build the block through the spec's State.build_block().

src/lean_spec/forks/lstar/spec.py

@@ -1603,13 +1603,27 @@ def update_safe_target(self, store: LstarStore) -> LstarStore:
         # The head and attestation pools remain unchanged.
         return store.model_copy(update={"safe_target": safe_target})
 
-    def aggregate(self, store: LstarStore) -> tuple[LstarStore, list[SignedAggregatedAttestation]]:
+    def aggregate(
+        self,
+        store: LstarStore,
+        *,
+        skip_trivial_inputs: bool = True,
+    ) -> tuple[LstarStore, list[SignedAggregatedAttestation]]:
         """Turn raw validator votes into compact aggregated attestations.
 
         Validators cast individual signatures over gossip. Before those
         votes can influence fork choice or be included in a block, they
         must be combined into compact cryptographic proofs.
 
+        ``skip_trivial_inputs`` (default ``True``) is an **aggregator-role**
+        policy: when set, the ``1 raw + 0 children`` shape is skipped because
+        a single-validator "aggregate" carries no consensus signal beyond the
+        raw gossip sig already on the network (see issue #747). Interval-2
+        aggregator ticks use the default. Block-building callers that must
+        fold every chosen ``att_data`` into ``latest_known_aggregated_payloads``
+        (including lone gossip sigs) pass ``skip_trivial_inputs=False`` —
+        see ``BlockSpec`` in the consensus-testing filler.
+
         The store holds three pools of attestation evidence:
 
         - **Gossip signatures**: individual validator votes arriving in real-time.
@@ -1676,31 +1690,19 @@ def aggregate(self, store: LstarStore) -> tuple[LstarStore, list[SignedAggregate
                 if e.validator_id not in covered
             ]
 
-            # Skip cases where running the prover provides no consensus value:
-            #
+            # Always skip cases where there is nothing to aggregate:
             #   - 0 raw + 0 children: nothing to aggregate.
-            #   - 0 raw + 1 child:    a lone child proof is already a valid
-            #                         proof; nothing to do.
-            #   - 1 raw + 0 children: a single-validator "aggregate" carries
-            #                         no information the raw gossip sig
-            #                         doesn't already carry — the sig is on
-            #                         the per-subnet `attestation_signatures`
-            #                         gossip topic at sign time, so any peer
-            #                         aggregator can fold it in as a raw
-            #                         entry next round. The recursive STARK
-            #                         prover is constant-cost in input size,
-            #                         so building a 1-validator proof spends
-            #                         the full prover budget for zero
-            #                         consensus signal. The unconsumed gossip
-            #                         sig stays in `store.attestation_signatures`
-            #                         (see bookkeeping below) and gets folded
-            #                         in by a future round once another sig
-            #                         or a child shows up.
-            if not child_proofs and len(raw_entries) <= 1:
-                continue
+            #   - 0 raw + 1 child:    a lone child proof is already valid.
             if not raw_entries and len(child_proofs) < 2:
                 continue
 
+            # Aggregator-role optimization (``skip_trivial_inputs=True``, the
+            # default): skip ``1 raw + 0 children``. Block-building callers
+            # pass ``skip_trivial_inputs=False`` so every gossip sig they
+            # seeded is folded into ``latest_known_aggregated_payloads``.
+            if skip_trivial_inputs and not child_proofs and len(raw_entries) <= 1:
+                continue
+
             # Encode raw signers as a compact bitfield when present.
             # Child-only aggregation (no raw signatures) must pass None.
             if raw_entries: