lgj-abi: the operand is what makes the differential a test, measured

Follow-up to the file it amends. The disable table ran five arms and all
five are red, but one of them settles a claim the previous commit only
asserted: that replacing the tautological `LE_I32(500)` operand mattered.

Mis-mapping `LGJ_OP_LE_I32` to `Pred::LtI32` in `plan_lower` — one token,
and the exact defect class `lowering_convergence.rs` exists to catch — is:

  operand 300 (shipped):  RED   `LeI32(300)` = 866, `LtI32(300)` = 865
  operand 500 (pre-fix):  GREEN both select all 1000

So at the operand the spec originally used, a real mis-map is INVISIBLE:
the two arms agree on an answer neither of them computed correctly. Two of
the nine opcodes would have shipped untested while the file read as
covering all nine.

Recorded where the claim lives — in `OPCODE_CASES`'s doc comment, beside
the measurement that chose the operand, with an explicit instruction not to
move it back under the "the domain doc says 361, so 500 is safely past it"
reasoning that put it there.

Disable table, all five red: the AND/OR asymmetry (an OR gated on the
accumulator); the prefix rewrite (`k := 0`); the one-opcode mis-map above;
the fold's OR node (flattened into the enclosing AND); the fold's dead
prefix (an OR before the first AND becoming a leaf).

182 lib tests, every integration binary green, clippy `-D warnings` + fmt
clean. Board: LATEST_STATE 2026-09-14 (6) amended with the table.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01X6y3drwKSE2zSgoexheLFX

Author: claude

.claude/board/LATEST_STATE.md

@@ -52,6 +52,25 @@ the fixture is dead:
 Both are now `assert_eq!`, measured, with the incident recorded at the
 assertion. Zero `TODO`s left in the file.
 
+**And the fixture fix is itself measured, not asserted.** Mis-mapping
+`LGJ_OP_LE_I32` to `Pred::LtI32` in `plan_lower` — a one-token change, and
+exactly the defect class this file exists to catch — is **RED at operand
+300** (`LeI32(300)` = 866, `LtI32(300)` = 865; one row is enough) and
+**GREEN at operand 500**, where both readings select all 1000 and the two
+arms agree on an answer neither computed correctly. So the operand is the
+difference between a test and a decoration, and the pre-fix version of this
+file would have shipped blind to a real mis-map on two of its nine opcodes.
+
+**Disable table — five arms, all red:**
+
+| arm | disable |
+|---|---|
+| the AND/OR asymmetry | `plan_lower` gates an OR on the accumulator |
+| the prefix rewrite | `plan_lower` takes `k := 0` always |
+| a one-opcode mis-map | `LGJ_OP_LE_I32` -> `Pred::LtI32` |
+| the fold's OR node | the fold flattens an OR into the enclosing AND |
+| the fold's dead prefix | an OR before the first AND becomes a leaf |
+
 Numbers, from `--nocapture`: per-opcode seeds 65 / 935 / 2 / 998 / 498 /
 676 / 866 / 500 / 65; the 28-vector sweep runs 39, 498, 524, 1000 (n=2),
 0, 40, 40, 73, 112, 531, 557, 1000 (n=3) — both identical to

native/lgj-abi/src/exports/tests/lowering_convergence.rs

@@ -458,13 +458,24 @@ fn the_all_rows_shortcut_is_the_same_condition_on_both_sides() {
 /// always-true on this lane — so a swapped entry in either mapping table
 /// would have passed, which is precisely the defect this file exists to
 /// catch. Measured (n = 1000, seed = 33): values span `-150..=361` with
-/// median 100, so `LT_I32(200)` selects 676 and `LE_I32(300)` selects 865.
+/// median 100, so `LT_I32(200)` selects 676 and `LE_I32(300)` selects 866.
 ///
 /// The four ordered comparisons are also given DISTINCT counts on purpose.
 /// This is a differential between two arms, not against ground truth, so a
 /// mis-map is visible only when it moves ONE arm's count — and two opcodes
 /// that happen to select the same number of rows would hide a swap between
 /// exactly those two.
+///
+/// That is not a theoretical worry; it was MEASURED on this exact file.
+/// Mis-mapping `LGJ_OP_LE_I32` to `Pred::LtI32` in `plan_lower` — a
+/// one-token change, and the precise defect class this test exists to catch
+/// — is RED at operand `300` (`LeI32(300)` selects 866, `LtI32(300)` selects
+/// 865: one row of difference is all it takes) and **GREEN at operand
+/// `500`**, where both readings select all 1000 and the arms agree on an
+/// answer neither of them computed correctly. The operand is what makes this
+/// a test rather than a decoration; do not move it back inside the "the
+/// domain doc says 361, so 500 is safely past it" reasoning that put it
+/// there.
 const OPCODE_CASES: [(&str, u32, u32, i64); 9] = [
     ("EQ_U32", LGJ_OP_EQ_U32, LANE_CLASSES, 7),
     ("NE_U32", LGJ_OP_NE_U32, LANE_CLASSES, 7),