@@ -252,7 +252,8 @@ class AlignmentBatch:
     V2 can shard on dim 0 without knowing about cross-tokenizer specifics.
 
     Attributes:
-        pair_valid: ``[B, max_pairs]`` bool. False on padding entries.
+        pair_valid: ``[B, max_pairs]`` bool. False on padding entries and on
+            pairs whose student or teacher tokens are all tokenizer padding.
         pair_is_correct: ``[B, max_pairs]`` bool. True when decoded student
             and teacher span texts are equal, when an NFC-validated native
             repair matches them, or when both spans are their tokenizer's
@@ -547,22 +548,41 @@ def _drop_padding(
         student_attention_mask: torch.Tensor | None,
         teacher_attention_mask: torch.Tensor | None,
     ) -> None:
-        """Strip tokenizer padding out of the chunk-id tensors.
+        """Strip tokenizer padding out of the chunk ids and invalidate padding pairs.
 
         Mutates ``batch`` in place. For every position the attention mask
         marks as padding, reset ``*_chunk_id`` to ``-1``. Gating per position
         (rather than trimming a contiguous span) keeps this correct under either
-        left- or right-padding. A pair whose tokens are entirely padding on
-        one side then has size 0 there and is dropped by
-        :func:`nemo_rl.algorithms.x_token.loss_utils.valid_chunk_mask`; a pair
-        straddling the real/pad boundary shrinks to its real tokens.
+        left- or right-padding; a pair straddling the real/pad boundary shrinks
+        to its real tokens. When both masks are given, a pair with tokens on
+        both sides whose student or teacher tokens are all padding becomes
+        invalid in ``pair_valid``. A pair with no tokens on one side (one-sided
+        by alignment) keeps its flag.
         """
+        max_pairs = batch.pair_valid.shape[1]
+        two_sided = TokenAligner._pairs_with_tokens(
+            batch.student_chunk_id, max_pairs
+        ) & TokenAligner._pairs_with_tokens(batch.teacher_chunk_id, max_pairs)
         if student_attention_mask is not None:
             s_pad = student_attention_mask == 0
             batch.student_chunk_id[s_pad] = -1
         if teacher_attention_mask is not None:
             t_pad = teacher_attention_mask == 0
             batch.teacher_chunk_id[t_pad] = -1
+        if student_attention_mask is None or teacher_attention_mask is None:
+            return
+        two_sided_real = TokenAligner._pairs_with_tokens(
+            batch.student_chunk_id, max_pairs
+        ) & TokenAligner._pairs_with_tokens(batch.teacher_chunk_id, max_pairs)
+        batch.pair_valid &= two_sided_real | ~two_sided
+
+    @staticmethod
+    def _pairs_with_tokens(chunk_id: torch.Tensor, max_pairs: int) -> torch.Tensor:
+        """``[B, max_pairs]`` bool: True where the pair owns a position of ``chunk_id``."""
+        # Column 0 counts the -1 sentinel; column p + 1 counts pair p.
+        counts = torch.zeros((chunk_id.shape[0], max_pairs + 1), dtype=torch.long)
+        counts.scatter_add_(1, chunk_id + 1, torch.ones_like(chunk_id))
+        return counts[:, 1:] > 0
 
     @staticmethod
     def _pairs_to_batch(
 
@@ -288,6 +288,43 @@ def test_align_padding_positions_receive_sentinel_chunk_id():
     assert bool((t_sizes[chunk_mask] > 0).all())
 
 
+def test_align_pair_valid_drops_padding_pairs():
+    """In a right-padded batch with rows of different lengths, the pairs over
+    padding are invalid, while real two-sided pairs and the student-only
+    start-of-text pair (one-sided by alignment) stay valid.
+    """
+    vocab = {0: "<pad>", 7: "<bos>", 1: "Hello", 2: "Ġworld", 3: "!"}
+    aligner = _make_aligner(vocab, vocab, bos_token_id=7, pad_token_id=0)
+
+    # Only the student starts with <bos>; row 1 is two tokens shorter.
+    student_ids = torch.tensor([[7, 1, 2, 3], [7, 1, 0, 0]], dtype=torch.long)
+    teacher_ids = torch.tensor([[1, 2, 3], [1, 0, 0]], dtype=torch.long)
+    student_offsets = torch.tensor(
+        [[[0, 0], [0, 5], [5, 11], [11, 12]], [[0, 0], [0, 5], [0, 0], [0, 0]]],
+        dtype=torch.long,
+    )
+    teacher_offsets = torch.tensor(
+        [[[0, 5], [5, 11], [11, 12]], [[0, 5], [0, 0], [0, 0]]], dtype=torch.long
+    )
+
+    batch = aligner.align(
+        student_ids,
+        teacher_ids,
+        student_offsets=student_offsets,
+        teacher_offsets=teacher_offsets,
+        student_attention_mask=student_ids.ne(0),
+        teacher_attention_mask=teacher_ids.ne(0),
+    )
+
+    # Pair 0 is <bos> alone; row 1's pairs 2-3 pair padding with padding.
+    assert batch.student_chunk_id.tolist() == [[0, 1, 2, 3], [0, 1, -1, -1]]
+    assert batch.teacher_chunk_id.tolist() == [[1, 2, 3], [1, -1, -1]]
+    assert batch.pair_valid.tolist() == [
+        [True, True, True, True],
+        [True, True, False, False],
+    ]
+
+
 def test_module_exposes_alignment_kernel():
     """The offset kernel is reachable from the package namespace (callers use
     it directly instead of poking at name-mangled internals).
 
@@ -404,7 +404,8 @@ def test_long_text_truncates_trailing_tokens_not_drops_sample(self):
 # Captured from the collator before the optional overlength and CE-turn
 # behaviors existed; the default batch must stay bitwise identical. Its first
 # row fills each side's context, so padding to the longest row keeps the
-# full-context width.
+# full-context width. ``alignment_0_pair_valid`` was recaptured when pairs
+# over padding became invalid.
 _TEXT_SNAPSHOT_CHECKSUMS = {
     "input_ids": 3661199532,
     "input_lengths": 868467641,
@@ -414,7 +415,7 @@ def test_long_text_truncates_trailing_tokens_not_drops_sample(self):
     "teacher_0_input_ids": 548984487,
     "teacher_0_input_lengths": 137384594,
     "teacher_0_token_mask": 3787835366,
-    "alignment_0_pair_valid": 64817739,
+    "alignment_0_pair_valid": 2277715625,
     "alignment_0_pair_is_correct": 13516310,
     "alignment_0_student_chunk_id": 1888554585,
     "alignment_0_teacher_chunk_id": 1481747482,
@@ -797,6 +798,29 @@ def test_batch_matches_full_context_padding_at_real_positions(self):
             for key in ("alignment_0_pair_valid", "alignment_0_pair_is_correct"):
                 assert torch.equal(new[key][row, pairs], old[key][row, pairs]), key
 
+    def test_pair_valid_counts_real_chunks(self):
+        """``pair_valid`` counts the pairs holding real tokens, including the
+        student-only start-of-text pair, and none of the pairs over padding.
+        """
+        batch = [_datum(text, idx=i) for i, text in enumerate(self._TEXTS)]
+        out = _text_collator(
+            ctx_length_student=16,
+            ctx_length_teachers=[64, 16],
+            student=_word_tokenizer(bos=True),
+            add_special_tokens_in_text=True,
+        )(batch)
+        real = 0
+        for row in range(len(batch)):
+            student = out["alignment_0_student_chunk_id"][row]
+            teacher = out["alignment_0_teacher_chunk_id"][row]
+            real += len(
+                set(student[student >= 0].tolist())
+                | set(teacher[teacher >= 0].tolist())
+            )
+        # One pair per word plus each row's start-of-text pair.
+        assert real == 8 + 3
+        assert out["alignment_0_pair_valid"].sum().item() == real
+
 
 class TestCollatorPadTokenFallback:
     def test_missing_pad_token_set_from_eos(self):