facet: revert the axis LCP to the PEEK chain; name the three prefix-fold carriers

.claude/board/EPIPHANIES.md

@@ -1,3 +1,97 @@
+## 2026-09-17 (17) — E-THREE-CARRIERS-THREE-FOLDS-1 — one workspace holds THREE prefix-fold carriers; entry (16) measured a real win on one of them and shipped it into another, where it is 2.1× SLOWER
+
+**Status:** MEASURED (`crates/lance-graph-contract/examples/facet_axis_lcp_probe.rs`,
+four arms, 64K pairs, min of 7, oracle-first, in-tree and reproducible) +
+SHIPPED (the revert, same PR). The carrier-2 opportunity is CONJECTURE — named,
+not measured.
+**Confidence:** HIGH on the numbers and the disassembly. The three-carrier
+taxonomy is a reading of the tree, offered as the strongest available
+explanation of (16)'s inversion, not as a proof of what (16) originally timed.
+
+### The correction
+
+Entry (16) records *"loop 12.5 ns → masked readout 5.8 ns"* for the facet
+per-axis LCP. **On the facet carrier that ordering is inverted.** Measured
+2026-09-17 on its own 64K-random workload, both axes, ns/op:
+
+| workload | A chain fold (retired by #1244) | C masked `u128` (shipped by #1244) |
+|---|---|---|
+| random | **1.72** | 3.64 |
+| depth 0 | **1.66** | 4.68 |
+| depth 5 | **3.50** | 3.56 |
+| identical | **3.30** | 3.73 |
+
+Arm A wins at every workload; on the entry's own workload by **2.1×**. Arm A
+depth-0 1.66 → depth-5 3.50 (+111%) — the early exit is real and is where the
+win comes from. Two further arms (a pack-to-`u64` PEEK, and a shared-load
+variant) were slower than both; the prediction that packing would win was
+wrong and is recorded as wrong.
+
+**⊘ Struck from (16): "the gather dominated".** The disassembly refutes the
+premise. LLVM never materializes the `[u8; 6]` and never gathers:
+
+```
+movzbl 0x5(%rdi),%eax     ; PEEK hi[0] of a
+cmp    0x5(%rsi),%al      ; compare straight against b's memory
+jne    <exit>             ; done — one tier compared
+movzbl 0x7(%rdi),%r8d     ; only now PEEK hi[1]
+```
+
+Arm C performs the *same* byte loads, then pays to reassemble them
+(`shl`/`or`), materialize `movabs $0xff00ff00ff00ff00`, run two `tzcnt` + a
+`cmove`, and apply the `−32` correction — and cannot exit early. It is strictly
+more work on the same loads.
+
+**What survives (16) unchanged:** the `-f` naming; `shared_prefix_tiles` (a
+genuine whole-register `xor`+`tzcnt`, different op, untouched); the entire
+ndarray `ternlogq` descent half (5–8× over padding — measured on its own
+carrier and not in question); the `−32` correction note; the 23-tail-site count.
+
+### Why it inverted — three carriers, three folds
+
+The same words ("prefix fold", "LCP", "shared depth") name three different
+operations on three different carriers. The op that is optimal on one is
+pessimal on the next, and nothing in the vocabulary flags the crossing.
+
+| # | carrier | shape | right fold | state |
+|---|---|---|---|---|
+| 1 | **bit-planes** — `mailbox_soa.rs` `identity_plane_at → &[u64]`, `N × WORDS_PER_FP` | sub-byte, no byte addresses | **mask / popcount** (`DistanceMeans::Hamming`) | correct, untouched |
+| 2 | **nibble path** — `NiblePath` (`hhtl.rs:251`), packed `u64`, 16 nibbles | sub-byte, packed into one register | **mask** — `xor` + `leading_zeros() >> 2` | **walks nibble-by-nibble today; the one real opportunity** |
+| 3 | **facet cascade** — `FacetCascade`, 6×2×8 bytes at fixed offsets | byte-addressed, offsets known at compile time | **PEEK** — `movzbl` + `cmp` + early exit | reverted to PEEK by this entry |
+
+The rule, in the operator's formulation (2026-09-17): **masking wins when the
+slice is granular; PEEK wins when the slice is addressed.** A fold result is
+scoped to its carrier and does not travel. (16)'s 12.5 ns is entirely plausible
+as a measurement of a *carrier-2-shaped* loop — a per-step walk against a
+packed integer, which is exactly what `common_prefix_depth` still is. What is
+not supportable is transferring that conclusion to carrier 3, where the loop
+compiles to compares against memory.
+
+### The opportunity this names (carrier 2 — CONJECTURE, unmeasured)
+
+`NiblePath::common_prefix_depth` is the fold `mailbox_scan.rs:263` actually
+calls for CAKES nearest-ranking. It walks up to 16 nibbles, each step a shift,
+an `Option` construct and a two-field compare, to compute what is
+`((a.path ^ b.path).leading_zeros() >> 2)` clamped to `min(depth)`. This is the
+carrier where (16)'s instinct was right and was never applied. **Gate:** the
+same four-arm probe harness, against this carrier, before any rewrite — the
+whole point of this entry is that a fold is not portable on argument alone.
+
+### The generalized rule
+
+**Before moving a fold, name its carrier.** A measurement is a statement about
+(operation, carrier, workload); dropping the carrier makes it a slogan. Any PR
+that changes a prefix/LCP/distance fold must state which of the three carriers
+it touches and carry a probe on *that* carrier. Sibling of the falsifiability
+rule in `CLAUDE.md`: an assertion implied by the code it tests is not a test,
+and a measurement transferred off its carrier is not a measurement.
+
+Doctrine: `.claude/knowledge/three-prefix-fold-carriers.md`.
+Blast radius: `.claude/plans/three-carrier-blast-radius-v1.md`.
+Cross-ref: (16) above (struck in part, cited in full); `E-PANCAKES-IS-RADIX-IS-HHTL`
+(carrier 2's doctrine); `E-VACUOUS-ASSERTION-IS-THE-HOUSE-STYLE-1` (the
+differential test was inverted in the revert so it stays falsifiable).
+
 ## 2026-09-16 (16) — E-FORMAT-SLOT-FOLD-IS-THE-SAME-OP-AS-THE-VL-DESCENT-1 — `"{0}{1}" -f hi,lo`: the register is a template with fixed arity, and both the facet LCP and the ternlogq tail are "pick the template whose arity matches the arguments, never pad them"
 
 **Status:** MEASURED on the ndarray side (the descent probe, ndarray
@@ -79,6 +173,20 @@ carried):**
   `pack<const L>` follow-up would retire all 23, not 12; whether the Morton-shift tail fits the same helper is
   part of that follow-up, not settled here.
 
+**⊘ PARTIAL STRIKE 2026-09-17 (appended; see entry (17)
+`E-THREE-CARRIERS-THREE-FOLDS-1` above).** The facet half of this entry is
+inverted on its own carrier: measured four ways in-tree, the retired chain fold
+is **1.72 ns** and the shipped masked readout **3.64 ns** on this entry's own
+64K-random workload — the opposite ordering, 2.1×. The premise *"the gather
+dominated"* is refuted by disassembly: LLVM never materializes the `[u8; 6]`.
+`shared_axis` is reverted to the chain fold; the masked form is retained as its
+test oracle. Everything else here stands unchanged — the `-f` naming,
+`shared_prefix_tiles`, the `−32` note, the 23-site count, and the whole ndarray
+`ternlogq` descent half (a different carrier, measured on its own and not in
+question). What the 12.5 ns actually timed is unknown — no harness was
+committed with it; entry (17) gives the strongest available account (a
+carrier-2-shaped loop) and labels it as such.
+
 ## 2026-09-16 (15) — E-THE-SPINE-IS-WHATEVER-THE-READER-ALREADY-HAS-AN-ADDRESS-FOR-1 — the operator's quack redirect, and the four errors of one session that all substituted an address for the thing
 
 **Status:** OPERATOR-RULED (the redirect, verbatim below) + MEASURED (the census

.claude/board/INTEGRATION_PLANS.md

@@ -1,3 +1,20 @@
+## 2026-09-17 (1) — three-carrier-blast-radius-v1 — how far do the three prefix-fold carriers reach, and where do they touch → `.claude/plans/three-carrier-blast-radius-v1.md`
+
+**Status:** PROPOSAL. Read-only census + seam map; gates only, no code
+authorized. Arose from `E-THREE-CARRIERS-THREE-FOLDS-1`: an optimization
+measured on the bit-plane/nibble side was shipped into the byte-addressed facet
+side, where it is 2.1× slower. The defect was a **scope error, not a bad
+optimization** — and no gate the workspace runs can see one, because the three
+carriers share a vocabulary ("prefix fold", "LCP", "shared depth").
+
+Four passes (type census · fold census · **seams** · outward radius), five
+gates (G-EXH / G-FOLD / G-SEAM / G-PROBE / G-ZERO). Pass 3 is the highest-value
+one: `mailbox_scan.rs` already consumes two carriers, which is the exact
+confusion surface. Explicitly NOT authorized: any carrier-2 rewrite before its
+own probe, any carrier-1 change, and any widening of `FacetTier`'s `u8:u8` to
+make a mask cheaper (`E-V3-FACET-4-PLUS-12` — the fold adapts to the layout,
+never the reverse).
+
 ## 2026-09-16 (1) — lance-graph-as-the-modelgraph-v1 — the ModelGraph stops being a transient Rust object and becomes addressed rows in the V3 SoA → `.claude/plans/lance-graph-as-the-modelgraph-v1.md`
 
 **Status:** PROPOSAL (operator-set endgame: *"endgame should be to wire

.claude/board/ISSUES.md

@@ -1,3 +1,37 @@
+## ISS-NIBLEPATH-FOLD-IS-CARRIER-2-UNMASKED (2026-09-17) — OPEN, the one prefix fold that genuinely wants a mask, and does not have one
+
+`NiblePath::common_prefix_depth` (`crates/lance-graph-contract/src/hhtl.rs`, `fn common_prefix_depth`) is
+carrier 2 per `.claude/knowledge/three-prefix-fold-carriers.md`: 16 nibbles packed into
+one `u64`, sub-byte, no byte addresses. It walks depth-by-depth, each step a shift, an
+`Option` construct and a two-field compare:
+
+```rust
+while d < max {
+    match (self.prefix(next), other.prefix(next)) {
+        (Some(a), Some(b)) if a.path == b.path && a.depth == b.depth => d = next,
+        _ => break,
+    }
+}
+```
+
+Up to 16 iterations for what is `((self.path ^ other.path).leading_zeros() >> 2)` clamped
+to `min(self.depth, other.depth)` — root-first, so `leading_zeros`, not `trailing_zeros`.
+
+**Live, not hypothetical:** `crates/lance-graph/src/graph/mailbox_scan.rs` (`pa.common_prefix_depth(pb)`) calls it for
+CAKES nearest-ranking (`E-PANCAKES-IS-RADIX-IS-HHTL`). Two further local copies of the
+same fold shape exist over `HhtlKey` in `crates/perturbation-sim/examples/`
+(`outage_over_hhtl_hops.rs:76`, `basin_placement_learning.rs:76`) and should be
+classified with it.
+
+**This is the opportunity the 2026-09-16 sweep was reaching for and applied to the wrong
+carrier** (`E-THREE-CARRIERS-THREE-FOLDS-1`). Which is exactly why it must NOT be rewritten
+on that entry's authority: **CONJECTURE until probed on this carrier.** Gate: the four-arm
+harness from `examples/facet_axis_lcp_probe.rs`, re-armed for `NiblePath`, with workloads
+covering `EMPTY`, unequal depths, ancestor pairs, and full-16 agreement — the depth clamp
+and the edge cases are where a fast prefix fold gets quietly wrong.
+
+Sequencing and the gates: `.claude/plans/three-carrier-blast-radius-v1.md` steps 4–5.
+
 ## ISS-LANCEDB-038-NEEDS-REMOTE-TO-COMPILE (2026-09-15) — OPEN, upstream bug, our `lancedb-sdk` feature does not build
 
 `lancedb 0.38.0` does not compile with its own default feature set. Measured, reading the

.claude/board/STATUS_BOARD.md

@@ -1,3 +1,17 @@
+## three-carrier prefix folds (D-ids minted 2026-09-17, plan `.claude/plans/three-carrier-blast-radius-v1.md`)
+
+Arose from the −32 offset correction sweep (#1244) and the operator's challenge to it.
+Doctrine: `.claude/knowledge/three-prefix-fold-carriers.md`. Board:
+`E-THREE-CARRIERS-THREE-FOLDS-1`.
+
+| D-id | scope | status | gate / falsifier |
+|---|---|---|---|
+| D-TCF-1 | probe the facet per-axis LCP four ways and settle which fold the byte-addressed carrier wants | **Shipped.** `examples/facet_axis_lcp_probe.rs`, 64K pairs, min-of-7, oracle-first. Chain PEEK **1.72 ns** vs masked `u128` **3.64 ns** on random; PEEK wins at every workload; the two pack-to-register arms are slowest | all four arms must agree with the shipped API before timing; the depth knob must bind (A: 1.66 → 3.50 ns over depth 0..5, +111%) — a flat slope would mean the early exit is not the mechanism |
+| D-TCF-2 | revert `shared_axis` to the chain fold; keep the differential test falsifiable | **Shipped.** Masked form retained as `masked_axis_oracle` under `#[cfg(test)]` — direction reversed so the test compares shipped-vs-oracle, not shipped-vs-itself | post-revert re-run reproduces the ordering (A 1.76 / C 4.48); 1354 contract tests green; the prior disable-run (swap hi/lo masks ⇒ fail at `hi flip at tier 0`) still holds on the oracle |
+| D-TCF-3 | name the three carriers and the law that separates them | **Shipped.** `.claude/knowledge/three-prefix-fold-carriers.md` — bit-planes / nibble path / facet cascade; *masking wins when the slice is granular, PEEK wins when the slice is addressed* | falsified by a fourth carrier, or by one carrier consuming another's fold. Two greps must stay empty: `FacetCascade` in `mailbox_soa.rs`; `trailing_zeros\|leading_zeros` in `hhtl.rs` |
+| D-TCF-4 | carrier-2 (`NiblePath::common_prefix_depth`) masked rewrite | **Queued — CONJECTURE, deliberately unbuilt.** `ISS-NIBLEPATH-FOLD-IS-CARRIER-2-UNMASKED`. This is the carrier the 2026-09-16 instinct was right about | must be probed on ITS OWN carrier first (G-PROBE). Landing it on entry (16)'s number would be the original defect recurring |
+| D-TCF-5 | blast-radius census of all three carriers + their seams | **Queued.** Plan above, passes 1–4, read-only | G-EXH (walk, not a chosen file list) · G-FOLD (every fold site carries a carrier) · G-SEAM (owner-in / owner-out / cost) · G-ZERO (a "no callers" claim verified by opening, never by an empty grep) |
+
 ## elk/ro factfinder — the meet, the horizon and their generality (D-ids minted 2026-09-15, probe `.claude/probes/elk-generality-v1/`)
 
 Arose from the EWA 12-hop fanout question ("would MQ offer a cheap gating"). No plan