planner: fix moore_tenant_isa_equivalence for the strict ISA (main build break)

.claude/board/entries/2026-10-08-hhtl-nars-moore-value-tenants.md

@@ -40,7 +40,7 @@ goes through `ValueTenant::value_offset()`, no literal offset.
 
 ## Tests (A–L)
 
-`moore_tenant.rs` (12 tests: A, B, C, D, E, G ×2, H, I, K, L);
+`moore_tenant.rs` (11 tests: A, B, C, D, E, G ×2, H, I, K, L);
 `cognitive-shader-driver/tests/moore_palette_pairs_lut.rs` (F);
 `lance-graph-planner/tests/moore_tenant_isa_equivalence.rs` (J, 2 tests:
 256 tenants × 8 lanes × 5 ops, 0 divergences on every field except the sign
@@ -68,5 +68,3 @@ Disable runs, each red then restored:
   cannot yet gate a consumer on them the way `bind_register128` does.
 - No production writer or reader. The production Simpson detector still takes
   bare edges and cannot refuse a Moore direction (pinned in #1406).
-- J uses `forward` as it is on `main`; #1407 (unmerged) changes it to return
-  `Result`, and J follows when that lands.

.claude/board/entries/README.md

@@ -25,7 +25,7 @@ index row, (3) no duplicate entry id. Checks 1 and 2 are deliberately
 opposite directions; the stranding this convention prevents shows up in
 exactly one of them, never both.
 
-269 entries, 2026-08-06 .. 2026-10-08.
+270 entries, 2026-08-06 .. 2026-10-08.
 
 | date | entry id | finding | file |
 |---|---|---|---|

crates/lance-graph-planner/tests/moore_tenant_isa_equivalence.rs

@@ -28,8 +28,15 @@ impl Rng {
     }
 }
 
+const MANTISSA: u64 = 0xF << 46;
+
+/// The codes the CE64 ISA executes (Ded +1, Ind +2, Abd -1, Rev +4, Syn +5)
+/// as raw 4-bit mantissa nibbles; `forward` refuses every other code.
+const EXECUTABLE: [u64; 5] = [0x1, 0x2, 0xF, 0x4, 0x5];
+
 fn canonical(r: &mut Rng, w: u64) -> u64 {
-    (r.next() & !W & !EPI5) | (w << 53) | ((r.next() % 24) << 59)
+    let code = EXECUTABLE[(r.next() % 5) as usize];
+    (r.next() & !W & !EPI5 & !MANTISSA) | (w << 53) | ((r.next() % 24) << 59) | (code << 46)
 }
 
 fn tables() -> [Box<[u8; 256 * 256]>; 3] {
@@ -53,8 +60,12 @@ fn ops(x: u64, y: u64, t: &[Box<[u8; 256 * 256]>; 3]) -> [u64; 5] {
     let mut ly = y;
     ly.learn(x, 0);
     [
-        x.forward(y, &t[0], &t[1], &t[2]).0,
-        y.forward(x, &t[0], &t[1], &t[2]).0,
+        x.forward(y, &t[0], &t[1], &t[2])
+            .expect("executable code")
+            .0,
+        y.forward(x, &t[0], &t[1], &t[2])
+            .expect("executable code")
+            .0,
         lx.0,
         ly.0,
         x.syllogize(y).expect("chain figure").conclusion.0,