diff --git a/.arxiv/0712.1182_fusion_needs_to_know_whether_evidence_is_independent.md b/.arxiv/0712.1182_fusion_needs_to_know_whether_evidence_is_independent.md
new file mode 100644
index 000000000..6da135c74
--- /dev/null
+++ b/.arxiv/0712.1182_fusion_needs_to_know_whether_evidence_is_independent.md
@@ -0,0 +1,40 @@
+# Cumulative and Averaging Fission of Beliefs — Fusion Must Know Whether Evidence Is Independent
+
+**Paper:** *Cumulative and Averaging Fission of Beliefs*, Audun Jøsang (UniK, University of Oslo)
+**arXiv:** 0712.1182v1
+**Source:** https://arxiv.org/abs/0712.1182
+**Read grade:** READ-IN-FULL (2026-10-08, coresearch "CE64 as BF16 for thinking")
+
+## Punchline
+
+> **There are two fusions, not one. Cumulative fusion adds independent evidence; averaging fusion combines two readings of the same evidence. Using the cumulative rule on dependent evidence counts it twice. And cumulative fusion has an inverse — fission — that removes a known contribution.**
+
+## What the paper establishes
+
+- Binomial opinion `(b, d, u, a)`, `b + d + u = 1`; `b + d = 0` is vacuous (§2.1).
+- **Cumulative fusion** (independent observers, disjoint periods): Case I `b = (bA·uB + bB·uA)/(uA + uB − uA·uB)`, `u = uA·uB/(uA + uB − uA·uB)`. It is commutative, associative and **non-idempotent** (Theorem 1). It equals a-posteriori updating of Dirichlet evidence: evidence counts add.
+- **Dogmatic case** (`uA = uB = 0`, Case II): `b = γ·bA + (1 − γ)·bB`, `u = 0`, with `γ = lim uB/(uA + uB)`. Associativity in Case II requires carrying γ as extra state (Theorem 1 and text after it).
+- **Averaging fusion** (dependent observers, same evidence): `b = (bA·uB + bB·uA)/(uA + uB)`, `u = 2uA·uB/(uA + uB)`. It is commutative and **idempotent**, not associative (Theorem 2).
+- **Fission** is the inverse: given a fused opinion and one contributor, recover the other (Theorems 3, 4). Cumulative fission is non-commutative, non-associative.
+- Dempster's rule is not used in subjective logic (§1).
+
+## Mapping to lance-graph (Q-A: the CE64 revision operator)
+
+NARS revision is cumulative fusion in evidence space: with `w = c/(1−c)` (horizon k = 1 in `isa::truth::revision`), pooled weights add (`ws = w1 + w2`). That makes it non-idempotent by construction — so **revising an edge with itself raises c**, which is the measured self-revision defect (`entries/2026-10-08-coresearch-ce64-moore-masking-wiring.md`, "no stamp check"). Jøsang names the missing distinction: the operator must know whether its two inputs are independent. NARS answers this with evidential-base (stamp) overlap; CE64's revision has no stamp, so it cannot tell cumulative from averaging situations.
+
+| paper concept | CE64 / lance-graph | status |
+|---|---|---|
+| cumulative fusion = evidence counts add | `revision`: `ws = w1 + w2` | HAVE |
+| averaging fusion (idempotent) for dependent inputs | none; self-revision double counts | MISSING — a stamp/evidential-base gate decides which rule applies |
+| dogmatic Case II with relative weight γ | c=255 + c=255 computes NaN -> 0 | the paper's math confirms the case needs a declared answer; adopting SL as a second calculus was REJECTED earlier (`moore-masking-wiring.md:119-120`) |
+| fission (remove a contribution) | in w-space, `w_A = w_C − w_B` | NEW reading: evidence-space revision is invertible, which gives detached/retractable revision (cf. `.arxiv/2608.16333`) |
+
+## Harvest
+
+1. Revision is cumulative fusion; it is only correct on independent evidence. The stamp gate (STAMP-GATE, open) is not an optimisation, it selects the fusion rule.
+2. Working in evidence space makes revision a commutative monoid that is cancellative: a known contribution can be subtracted exactly (fission), which suits detached revision and replay. This holds only away from the dogmatic edge, where w is infinite.
+3. Subjective logic stays rejected as a second calculus; only its case analysis (dogmatic limit, cumulative vs averaging) is harvested.
+
+## Kill condition
+
+The fission reading is dropped if, on the u8 grid, `revision(revision(a, b), fission-inverse of b)` does not return `a` within one code for c < 254 (quantisation destroys invertibility at 8 bits).
diff --git a/.arxiv/1905.12322_narrow_storage_wide_accumulate_round_once.md b/.arxiv/1905.12322_narrow_storage_wide_accumulate_round_once.md
new file mode 100644
index 000000000..770548a0a
--- /dev/null
+++ b/.arxiv/1905.12322_narrow_storage_wide_accumulate_round_once.md
@@ -0,0 +1,39 @@
+# BFLOAT16 — Narrow Storage, Wide Accumulate, Round Once
+
+**Paper:** *A Study of BFLOAT16 for Deep Learning Training*, Kalamkar, Mudigere, Mellempudi, Das, et al. (Intel Labs, Facebook)
+**arXiv:** 1905.12322v3
+**Source:** https://arxiv.org/abs/1905.12322
+**Read grade:** READ-IN-FULL (2026-10-08, coresearch "CE64 as BF16 for thinking")
+
+## Punchline
+
+> **A narrow format wins when it keeps the range, gives up precision, and is only ever an operand: every sum lives in a wider accumulator and is narrowed once, at the store.**
+
+## What the paper establishes
+
+- BF16 is FP32 with the low 16 mantissa bits dropped: same 8-bit exponent, 7-bit mantissa (Table 1). The claim to fame is the range, not the precision: "no hyper-parameter tuning is required", whereas FP16 needs loss scaling and INT16 needs block scaling (§1, §3).
+- All three half-precision methods share one schema: 16-bit operands, 32-bit accumulators (§1). GEMMs accept BF16 inputs and accumulate into FP32 outputs (Figure 1).
+- Conversion is round-to-nearest-even on the dropped bits (§1, Quantlib).
+- Truncation instead of RNE costs a small but real amount: Deep & Cross log-loss 0.44372 (RNE) vs 0.44393 (truncation); the authors call 0.001 log-loss "unacceptable in practice" (§4.4, Table 5).
+- Bias tensors stay FP32; the weight update uses an FP32 master copy (§3).
+
+## Mapping to lance-graph (Q-A only: CE64 F/C, bits 24..39)
+
+CE64 is a 64-bit tagged instruction word, not a number format (premise audit, entries/2026-10-08-coresearch-ce64-bf16-for-thinking.md). The BF16 analogy applies only to the two u8 truth scalars F and C and to the truth ALU in `causal_edge::isa::truth`.
+
+| BF16 property | CE64 F/C counterpart | status |
+|---|---|---|
+| narrow operand, wide accumulate | `revision` decodes u8 -> f32, pools in f32, re-encodes once per call (`isa.rs:216-261`) | HAVE per call |
+| round once, at the store | chains (`replay_step`) and `NarsTables` re-quantise per hop / into 16 c-bins | MISSING across chains |
+| RNE at the narrowing | `(x*255).round()` is half-away-from-zero; exact .5 ties exist in revision's integer form (e.g. c1=c2=45 -> 76.5) | rounding mode undeclared |
+| master copy in wide precision | none: the u8 code is the only state | WRONG-TO-COPY (the record is the canonical copy; a fold-side wide summary is the lawful analogue) |
+
+## Harvest
+
+1. Evidence is accumulated in the wide domain (`w = c/(1-c)`, or the integer form `c/(255-c)`), and narrowed to u8 C exactly once, at the store. Multi-step reasoning that re-encodes every hop is the "per-layer truncation" BF16 avoided.
+2. For populations (D-RPF-4), the wide accumulator is a fold-side summary (`Σw`, `Σw·f`), never a second stored copy in the row.
+3. Rounding mode is a declared property of the narrowing step, not an accident of `f32::round`.
+
+## Kill condition
+
+If a chain of N weak same-sign revisions re-encoded per hop never differs by more than one code from the wide-accumulate-round-once result, the "round once" rule is cosmetic for CE64 (probe P-X1 in the coresearch entry).
diff --git a/.arxiv/2209.05433_special_values_are_declared_not_computed.md b/.arxiv/2209.05433_special_values_are_declared_not_computed.md
new file mode 100644
index 000000000..0fb2d55ff
--- /dev/null
+++ b/.arxiv/2209.05433_special_values_are_declared_not_computed.md
@@ -0,0 +1,41 @@
+# FP8 Formats — Special Values Are Declared, Not Computed
+
+**Paper:** *FP8 Formats for Deep Learning*, Micikevicius, Stosic, Judd, Kamalu, Oberman, Shoeybi, Siu, Wu (NVIDIA); Burgess, Ha, Grisenthwaite (Arm); Mellempudi, Cornea, Heinecke, Dubey (Intel)
+**arXiv:** 2209.05433v2
+**Source:** https://arxiv.org/abs/2209.05433
+**Read grade:** READ-IN-FULL (2026-10-08, coresearch "CE64 as BF16 for thinking")
+
+## Punchline
+
+> **At 8 bits, every code is precious and the edge codes are policy. E4M3 drops infinity, keeps a single NaN pattern, and saturates overflow to the largest finite value — a format decision, written down, not an arithmetic accident.**
+
+## What the paper establishes
+
+- Two encodings: E4M3 (weights, activations) and E5M2 (gradients). E5M2 keeps IEEE special values; E4M3 represents no infinities and only one mantissa pattern for NaN (S.1111.111), gaining one binade (max 448 instead of 240) (§3.1, Table 1).
+- Operations on FP8 inputs produce higher-precision outputs, optionally narrowed to FP8 before the store (§2).
+- Overflowing values "are then saturated to the maximum representable value"; skipping updates on overflow is a poor fit at 8 bits because overflows are frequent (§2).
+- Converting a wide Inf or NaN to E4M3 yields NaN; a non-saturating conversion mode can be offered for strict overflow handling (§2).
+- "Rounding mode (round to nearest even, stochastic, etc.) choice is orthogonal to the interchange format and is left up to the implementation" (§2).
+- Scaling lives in software, per tensor, not in a programmable exponent bias (§3.2).
+
+## Mapping to lance-graph (Q-A: CE64 C, bits 32..39)
+
+The CE64 confidence byte has its own edge-code problem. Code 255 decodes to exactly 1.0, and `evidence_weight(1.0)` is `f32::MAX`; revising two 255 operands computes `inf/inf = NaN`, which the saturating `as u8` cast stores as **0** — "certain plus certain becomes no evidence" (`isa.rs:216-261`, pinned non-normative in `tests/ce64_isa_golden.rs:253-273`).
+
+The integer form of revision (with `w = c/(255-c)`) is `c_out·255 = 255·N/D`, `N = c1(255-c2) + c2(255-c1)`, `D = 255² - c1c2`. At `c1 = c2 = 255`, N = D = 0: the dogmatic case is **0/0 even in exact arithmetic**. So it is not a floating-point bug that better arithmetic would fix; like E4M3's top code, it needs a declared answer.
+
+| FP8 move | CE64 C equivalent | fit |
+|---|---|---|
+| saturate overflow to max finite | arithmetic never writes 255 (saturate at 254), decode of 255 unchanged | fits, gated per I-LEGACY-API-FEATURE-GATED |
+| one reserved NaN code | give 255 a new stored meaning ("dogmatic") | CONFLICTS-ANCHOR: re-reads frozen v2 bits |
+| rounding mode left to the implementation | `isa::contracts` should declare it | fits (additive) |
+| per-tensor software scale | truth has a fixed decode; no scale | WRONG-TO-COPY |
+
+## Harvest
+
+1. The c=255 cell is a policy cell. The smallest fit is the prior-art fix: cap c before `evidence_weight` (as the f64 reference already does), behind a version gate, with the golden flipped from "pins the defect" to "pins the policy".
+2. NaN -> 0 through a saturating cast erases information silently. FP8's own documentation of special-value conversion is the precedent for declaring the mapping in the op's contract.
+
+## Kill condition
+
+If capping c at 254 before `evidence_weight` yields 0 NaN, 0 monotonicity violations, and agreement with the exact integer form on all 65,535 non-(255,255) (c1,c2) pairs, no special code is needed and option "reserved dogmatic code" is closed (probe P-X2).
diff --git a/.arxiv/2310.10537_shared_scale_lives_outside_the_element.md b/.arxiv/2310.10537_shared_scale_lives_outside_the_element.md
new file mode 100644
index 000000000..9ee02e81e
--- /dev/null
+++ b/.arxiv/2310.10537_shared_scale_lives_outside_the_element.md
@@ -0,0 +1,36 @@
+# Microscaling (MX) — The Shared Scale Lives Outside the Element, and the Axis Matters
+
+**Paper:** *Microscaling Data Formats for Deep Learning*, Bita Darvish Rouhani, Ritchie Zhao, et al. (Microsoft, AMD, Intel, Meta, NVIDIA, Qualcomm)
+**arXiv:** 2310.10537v3
+**Source:** https://arxiv.org/abs/2310.10537
+**Read grade:** READ-IN-FULL (2026-10-08, coresearch "CE64 as BF16 for thinking")
+
+## Punchline
+
+> **Give a block of k narrow elements one shared power-of-two scale, kept beside them rather than inside them. It works — but the scale is a lossy quantisation, and quantising along one axis does not commute with transposing to another.**
+
+## What the paper establishes
+
+- An MX block is k scalar elements plus one shared scale X; value `v_i = X·P_i` (§2, Figure 1). "The layout of an MX block is not prescribed — an implementation may store X contiguously with or separately from the elements."
+- All concrete MX formats use k = 32 and an E8M0 scale (Table 1). The scale is `2^(floor(log2 max|V_i|) − emax_elem)`; elements that overflow are clamped to the element maximum; Inf and NaN are not clamped (Algorithm 1). A NaN scale makes the whole block NaN; the scale never encodes Inf (§2.1).
+- Dot products produce outputs in a scalar float format (BF16/FP32); vector ops stay in scalar float; a master FP32 weight copy is kept (§4.1).
+- "Conversion to MX format and transposing are not commutative operations", so the quantised weights and their transpose are stored as two tensors (§3, §4.1).
+- Rounding: RNE for inference conversions, round-half-away-from-zero in the training runs (§4.3, §4.5).
+
+## Mapping to lance-graph (Q-A: folds over F/C; D-RPF-4)
+
+CE64 truth has a fixed decode (`u8/255`) with no dynamic range to scale, so a per-record scale has nothing to do — WRONG-TO-COPY inside the row, which the frozen v2 layout forbids anyway.
+
+The one tempting place is a population fold (D-RPF-4: `Σw`, `Σw·f` over a masked population). Two findings from the paper argue against using MX there:
+
+1. A block-scaled summary is lossy, and the lane-fold capstone rule is that a lossy decomposition is never a fold. An exact fold exists: the integer evidence weights `c/(255−c)` summed in i128 (or u32 for capped c — `254·256·65536 < 2³²`) need no scale.
+2. The axis lesson transfers directly: a summary built along rows (a fold over a population) and one built along fields (a bit-sliced plane) are different quantisations. They cannot be swapped without recomputation, which is why a bit-sliced copy is a derived lane, never an equivalent representation.
+
+## Harvest
+
+- MX's "scale beside the element, not inside it" is the same move as the D-RPF rule "summaries are fold-side, the row stays as stored".
+- For truth folds, prefer the exact integer evidence fold; a block-scaled summary may at most be reported as a documented approximation beside it (the status D-RPF-7 gives an SVD truncation).
+
+## Kill condition
+
+The block-scale idea is closed if a fixed global Q8 scale over capped evidence weights gives at most one code of error on every test population at 64K rows (probe P-X8). If it does not, the exact fold is still preferred; MX would only be a reporting format.
diff --git a/.arxiv/2603.24161_stagnation_is_a_rounding_property.md b/.arxiv/2603.24161_stagnation_is_a_rounding_property.md
new file mode 100644
index 000000000..b56b2722b
--- /dev/null
+++ b/.arxiv/2603.24161_stagnation_is_a_rounding_property.md
@@ -0,0 +1,39 @@
+# Limited-Precision Stochastic Rounding — Stagnation Is a Rounding Property
+
+**Paper:** *Probabilistic Error Analysis of Limited-Precision Stochastic Rounding: Horner's Algorithm and Pairwise Summation*, El-Mehdi El Arar, Massimiliano Fasi, Silviu-Ioan Filip, Mantas Mikaitis
+**arXiv:** 2603.24161v1
+**Source:** https://arxiv.org/abs/2603.24161
+**Read grade:** READ-IN-FULL (2026-10-08, coresearch "CE64 as BF16 for thinking")
+
+## Punchline
+
+> **Round-to-nearest stagnates when small same-sign increments meet a large running total; stochastic rounding fixes it with a handful of random bits. But it buys accuracy in expectation, not per run — a different contract from replayable state.**
+
+## What the paper establishes
+
+- Stochastic rounding (SR) rounds up with probability proportional to the distance to the lower neighbour, so `E[SR(x)] = x` (Def. 1).
+- Deterministic rounding has worst-case error bounds growing as O(n·u); SR gives probabilistic bounds O(√n·u) (§1).
+- Limited-precision SR with r random bits is biased: `E[SR_{p,r}(x)] = fl_{p+r}(x)` (Def. 2, Eq. 4). Its bounds are ∝ √n·u_p + n·u_{p+r}; the rule of thumb is r ≈ ⌈log2(k)/2⌉ for error chains of length k (Remarks 2, 4).
+- Stagnation under RN appears with same-sign data (coefficients in [0,1]); with mixed signs RN errors partly cancel and SR's advantage shrinks (§5.1). Pairwise summation largely avoids stagnation (§5.2).
+- IEEE P3109 already specifies three limited-precision SR variants (Remark 1).
+
+## Mapping to lance-graph (Q-A: CE64 C under repeated revision)
+
+Repeated revision of an edge with small same-sign evidence is the same shape as summing small positive terms into a large total in a coarse format: a step whose Δw moves c by less than half a code rounds back to the same u8 C. Whether this happens on the real path is **unmeasured**.
+
+The measured failure points the other way: chain confidence 200 -> 224 -> 237 saturates because `replay_step` revises on every hop and nothing stops double counting (`entries/2026-10-08-coresearch-ce64-moore-masking-wiring.md`). SR does nothing for over-accumulation.
+
+| SR property | CE64 fit |
+|---|---|
+| unbiased in expectation | conflicts with replayable, deterministic state unless the random bits are hashed from (stamp, step) |
+| changes `revision` outputs | I-LEGACY-API-FEATURE-GATED: feature gate or new entry point |
+| error bound assumes mean independence | I-NOISE-FLOOR-JIRAK: CE64 bits are weakly dependent; bounds must cite weak-dependence rates |
+
+## Harvest
+
+1. Measure stagnation before choosing a remedy. The cheaper remedy is BF16's (accumulate wide, round once), which is deterministic.
+2. If SR is ever adopted, the random bits must be a deterministic hash, the bit count follows ⌈log2(chain length)/2⌉, and it lives behind a feature gate.
+
+## Kill condition
+
+SR is dropped if a grid of same-sign weak-revision chains (start codes {0..254}, increment codes {1,4,16,64}, N up to 1000) shows zero steps where the per-hop RN code stalls while the wide accumulator advances (probe P-X1/X6).
diff --git a/.claude/board/entries/2026-10-08-coresearch-ce64-bf16-for-thinking.md b/.claude/board/entries/2026-10-08-coresearch-ce64-bf16-for-thinking.md
new file mode 100644
index 000000000..c9711f362
--- /dev/null
+++ b/.claude/board/entries/2026-10-08-coresearch-ce64-bf16-for-thinking.md
@@ -0,0 +1,265 @@
+# 2026-10-08 — Coresearch: "CausalEdge64 is like BF16 for thinking"
+
+**Status:** EXPLORATION MAP. Nothing ratified, nothing adopted. Five scouts,
+three co-architects, premise gate; probes are pre-registered, not run (one
+main-thread arithmetic check is marked as such).
+**Operator baseline:** "ALU, ISA, causaledge64 is like BF16 for thinking."
+**Harvest:** five papers read in full by the main thread and written to
+`.arxiv/` (1905.12322, 2209.05433, 2603.24161, 0712.1182, 2310.10537).
+
+## Premise gate: PREMISE-SPLIT
+
+`premise-auditor`:
+- **CE64 is not a number format.** It is a fixed-width tagged record, i.e. an
+  instruction word of nine fields: identity (SPO), truth (F, C), codes (Pearl,
+  Direction), opcode (Inference), flags (Plasticity), handle (Witness) and a
+  state code (Epi5). Each op declares per field whether it computes, passes or
+  constant-sets it (`isa.rs:377-472`).
+- **"BF16 for thinking" holds for bits 24..39 only.** F and C are two u8
+  fixed-point truth scalars, and `isa::truth` is their ALU. Rounding, range and
+  accumulation vocabulary applies there and nowhere else. "Not applicable —
+  wrong category" is the verdict for every other field.
+
+The question was therefore asked as two:
+- **Q-A (format):** the F/C truth number.
+- **Q-B (instruction word):** the whole 64-bit record read in place.
+
+**The infographic's readings are different concepts from the code:**
+
+| bits | infographic reading | code |
+|---|---|---|
+| 46..49 | "activation" | the signed opcode: sign = chain direction, magnitude = NARS rule (`layout.rs:17-26`) |
+| 50..52 | "entropy/novelty" | three per-plane hot/frozen flags (`plasticity.rs`) |
+| 53..58 | "W1/W2/W3 belief update" | a corpus root handle that `forward` and `syllogize` zero (`isa.rs:392,440`) |
+| 40..42 | "Pearl ladder" | `pearl::CausalMask`, a 2³ plane-subset lattice |
+
+On the last row: `SO = 0b101` (Association) and `PO = 0b011` (Intervention) are incomparable subsets (`pearl.rs:37-77`), so "rung ≥ k" is not an up-set of this field. Read as a ladder ordinal, it is CONFLICTS-ANCHOR. Read as a plane mask, it is consistent.
+
+## Verified ground (code)
+
+- **Encode/decode.** Decode is `u8/255`. Encode is `(x.clamp(0,1)*255).round()`, which rounds half away from zero; NaN becomes 0 through the saturating cast (`edge.rs:322-340, 805-806`).
+- **Revision.** `w = c/(1−c)` gives horizon k = 1, and `evidence_weight` returns `f32::MAX` only for code 255 (`isa.rs:216-261`).
+  - Two operands at 255: c = inf/inf = NaN, stored as 0.
+  - One operand at 255: c = 255.
+- **Four quantisers for one concept:**
+  - `isa` revision;
+  - contract `NarsTruth`: capped at 0.99, with a +1e-9 term;
+  - `NarsTables`: c in 16 bins, `deduce` c_out = f_out, not used by the live ISA;
+  - `TruthU8` (arm-discovery): integer floor, never produces 255.
+
+  There is no integer truth ALU.
+- **Folds.** mask-risc `MaskedStridedGroupSum` (`ir.rs:309`) already gives an unweighted ΣF / ΣC over a masked population, in place. No weighted fold exists.
+- **ndarray.** It has u8 saturating add/sub, a u8×i8 VNNI dot and BF16 RNE. Stochastic rounding is ABSENT (closed grep).
+
+**MAIN-THREAD ARITHMETIC CHECK** (a numpy f32 model of `isa::truth::revision`, NOT the Rust code; it needs the Rust probe to confirm).
+
+With `w = c/(255−c)`, revision has an exact integer form:
+
+```text
+c_out·255 = 255·N/D
+N = c1(255−c2) + c2(255−c1)
+D = 255² − c1c2
+```
+
+- `c_out` depends only on `(c1, c2)`, so the c side is 65,536 cases.
+- At `c1 = c2 = 255`, N = D = 0. The dogmatic case is 0/0 even in exact arithmetic: a policy question, not a float bug.
+- The f32 model agrees with the exact form on all but 3 of 65,535 pairs. All three are exact .5 ties that f32 lands just below: `(45,45) → 76.5` and `(85,165)/(165,85) → 178.5`.
+- There are 0 monotonicity violations in c2.
+- So the rounding mode is not cosmetic for any integer reference ALU.
+
+## Crosswalk and verdicts
+
+Relation codes: HAVE / PARTIAL / NEW / CONFLICTS-ANCHOR. Firewall codes: PASS / CONFLICT (fits only behind a named seam) / TRAP.
+
+| # | idea | outside source | relation | firewall | verdict |
+|---|---|---|---|---|---|
+| X1 | narrow storage, wide accumulate, round once | BF16 1905.12322; TPU and VDPBF16PS docs | PARTIAL: one op already does it; chains and `NarsTables` re-quantise | CONFLICT; seam: fold-side or new entry only | **PROBE** P-X1 |
+| X2 | c=255 is a policy cell | FP8 2209.05433; posits; Jøsang 0712.1182; PCRLLM 2511.08392 | PARTIAL | (a) cap or saturate at 254: CONFLICT, seam = I-LEGACY gate. (b) give 255 a stored "dogmatic" meaning: TRAP | **PROBE** P-X2, then a policy decision; (b) **SKIP** |
+| X3 | rounding/saturation/c255 policy declared in the op contract | VDPBF16PS; VNNI wrap vs saturate | PARTIAL: `isa::contracts` lacks these fields | PASS (additive) | **PROBE** P-X3 (tie count; the model already found 2 distinct ties) |
+| X4 | one concept, four quantisers (lower bound; see ⊘ below) | OCP vs FNUZ name hazard | HAVE (the hazard) | diagnosis PASS; unifying them CONFLICT (I-LEGACY, unknown NarsTables callers) | **ADOPT-NOW as an ISSUE**; **PROBE** P-X4 parity grid |
+| X5 | integer-only truth ALU | Jacob 1712.05877 | NEW | CONFLICT; seam: an A4 oracle or a T1 primitive, never a substitute | **PROBE** P-X5 (folded into P-X2) |
+| X6 | stochastic rounding against stagnation | 2603.24161 | NEW | TRAP as proposed: determinism, I-LEGACY, Jirak | **PARK** until P-X1 shows stagnation |
+| X7 | evidence space as the currency | posit, LNS 2012.03458, SL/NARS | PARTIAL | exact Σw/Σw·f internal: CONFLICT with seam; log-w or Mitchell: TRAP (lossy) | **PROBE** P-X7 (exact fold); log-w **SKIP** |
+| X8 | MX block scale | 2310.10537 | NEW | TRAP as a terminal (lossy) | **SKIP**, unless P-X8 finds the exact fold insufficient |
+| X9 | predicted scaling (Transformer Engine) | TE docs | NEW | TRAP | **SKIP** |
+| X10 | (F,C) as an interval `[fc, fc+1−c]`; C is the information order | Wang; Belnap/Ginsberg | PARTIAL | PASS | **ADOPT-NOW** (doc line) |
+| X11 | contradiction magnitude as a transient output | Dempster–Shafer conflict; Belnap B | NEW | PASS as a sibling fn; a stored B flag is a TRAP | **PROBE** P-X11. The DS form `K = c1c2[f1(1−f2)+f2(1−f1)]` is predicted to fail (non-zero on `x+x`); the candidate is `K₂ = c1c2·\|f1−f2\|` |
+| X12 | subjective-logic opinions as the belief number | Jøsang | CONFLICTS-ANCHOR (earlier rejection) | TRAP | **SKIP**; only the case analysis is harvested |
+| X13 | bits 40..42 are a plane lattice | PCH / CHT 2401.02602 | HAVE (the code is right) | PASS; an ordinal "rung ≥ k" predicate is a TRAP | **ADOPT-NOW** (doc line + guard test, P-X13) |
+| X14 | Epi5 order = chain6 × poset4 | lattice theory | HAVE | PASS | cite only; P-X14 pins cover size == n+1 |
+| X15 | FCA: eligibility extents bounded by the concept lattice | Ganter–Wille | PARTIAL (never counted) | PASS | **PROBE** P-X15: sizes D-RPF-1's covers below the separable 24+8 bound |
+| X16 | illegal encodings trap | RISC-V rationale | PARTIAL: an all-zero operand already faults in `forward` | status quo PASS; making all-zero data illegal is a TRAP | **PROBE** P-X16 (pin; check `revise(x, 0) == x`) |
+| X17 | predicate separate from data; merge vs zero declared | SVE, AVX-512 writemask | HAVE (law A2) | PASS as documentation | **PROBE** P-X17 (pin learn's frozen planes 8/8) |
+| X18 | opcode from the instruction, not from an operand | ISA practice | PARTIAL (PARKED earlier) | CONFLICT; seam: a new additive entry point | **PARK** |
+| X19 | MSB-first early stop for strided predicates | BitWeaving/V SIGMOD13 | PARTIAL | PASS (an exact stop in ndarray::simd, plus an A4 differential) | **PROBE** P-X19 |
+| X20 | bit-sliced F/C beside the row | SIMDRAM 2012.11890; FastLanes | NEW | persisted: TRAP (a second copy); per-tile transient in scratch: PASS | **PROBE** P-X20, transient only; prefer the strided pattern covers from R-MHB-1 |
+| X21 | infographic readings stored in bits | operator image | CONFLICTS-ANCHOR | TRAP | **SKIP** as stored meaning; "novelty" may be the derived K₂ |
+
+⊘ **Correction to X4 (main thread, after the map, VERIFIED-IN-CODE).** The
+scouts reported `NarsTables` as "not used by the live ISA, callers unchecked".
+It is used: `lance-graph-planner` `NarsEngine::new` builds `NarsTables::build(1)`
+(`cache/nars_engine.rs:451`), and `chain_admission.rs:227` replays chains with
+it. With `c_levels = 1`, `revise` maps every confidence to bucket 0
+(`tables.rs:118-120`), so the planner's default revision is **confidence-blind**
+(its own doc calls this "confidence inert"). "Four quantisers" is a lower bound:
+37 files under `crates/` define a function named `revise` or `revision`; they
+were not read, so the true count is open (gap G4).
+
+## Epiphany candidates
+
+These have not been admitted to `EPIPHANIES.md`. Each passes the "would it matter without the defect?" test as stated by the bridge architect, and still needs its probe.
+
+1. **CE64 is an instruction word wrapped around a 16-bit reasoning number.**
+   - The BF16 analogy is exact for F/C: range over precision, wide accumulate, round once, declared edge codes.
+   - Everything else is an opcode, a predicate, a handle or a tag, read through its own order structure.
+2. **One truth quantiser, declared in the contract** (X1–X5, X16).
+   - Encode, decode, rounding, saturation, the meaning of code 255 and the accumulation width are implicit in four places today.
+   - Declare them once in `isa::contracts`. Every other quantiser then becomes a tested reading of that declaration.
+3. **Revision is cumulative fusion in evidence space** (X1, X7, X20; harvest from 0712.1182).
+   - In evidence space it is an exact, cancellative sum. That gives:
+     - **D-RPF-4:** a 256-entry `c → w` table applied per byte, then the existing strided group-sum. No new opcode is needed.
+     - **Fission:** removing a known contribution, for detached revision.
+     - **The stamp gate selects the rule:** cumulative fusion applies only to independent evidence, and averaging fusion is the idempotent one. The self-revision defect is this missing gate.
+4. **Contradiction is a transient output, not a state** (X10, X11, X21, and the optics "cancellation loses contradiction").
+   - Revision is information-monotone but folds "both" into "balanced".
+   - `K₂ = c1c2·|f1−f2|` reports the disagreement without storing it.
+   - The DS form is predicted to be wrong, because it fires on `x ⊕ x`.
+5. **Predicates follow the field's order, not its bit width** (X13–X15).
+   - Pearl is a subset lattice; Epi5 is chain × poset; C is the information order; F is the truth order.
+   - A threshold is only well-posed over a chain.
+   - D-RPF-1 cover sizes are bounded by the concept lattice of the eligibility table.
+
+## Pre-registered probes
+
+Size is S, M or L. Every guard probe has a can-fire half and a can-stay-silent half.
+
+**P-X2 + P-X5** (S, next to `tests/ce64_isa_golden.rs`)
+- **Grid:** all 65,536 `(c1,c2)` pairs, plus `c ∈ {253,254,255}` × all f values.
+- **Count:** NaN results, zero-stores, and monotonicity violations.
+- **Compare three forms:** current `isa`; capped at 254 before the weight; the exact integer form.
+- **Kill (b):** the cap gives 0 NaN, 0 violations, and agreement on all 65,535 non-(255,255) pairs.
+- **Baseline pin:** exactly the (255,255) cell family, using `==`.
+
+**P-X1/X6** (S, new `tests/ce64_chain_rounding.rs`)
+- **Input:** same-sign weak-revision chains, N up to 1000.
+- **Compare three forms:** re-encode per hop; f64 accumulate with one round at the end; hashed stochastic rounding.
+- **Kill SR:** stagnation = 0 over the whole grid.
+- **Kill X1:** `max|Δ| ≤ 1` code.
+
+**P-X3** (S)
+- **Measure:** count exact .5 ties over the revision grid.
+- **Kill:** count = 0 makes the declaration cosmetic. The model already predicts ≥ 2.
+
+**P-X4** (S–M)
+- **Input:** a differential across the four quantisers on a common grid.
+- **Kill unification:** all pairs agree within 1 code on non-255 cells.
+
+**P-X7/X8** (S)
+- **Input:** a sequential pairwise fold vs the closed form `Σw / Σw·f` over random permutations.
+- **Kill:** one distinct code per population. Expected outcome: it fails, so the exact Σ terminal is needed.
+
+**P-X11** (S)
+- **Check:** `K₂(x,x) = 0` for all x, and `K₂((1,c),(0,c)) > K₂((½,c),(½,c))`.
+- **Prediction:** the DS form K fails on `x + x`.
+
+**P-X13/X14/X15** (S, next to the affordance law and `resident_ce64_predicate.rs`)
+- Pearl monotone under ⊆.
+- An Epi5 threshold cover equals n+1.
+- Count distinct `facts_population` extents, and sum the minimal ternary covers against the 24+8 bound.
+- **Kill X15:** no reduction.
+
+**P-X16/X17** (S)
+- Pin the operand-zero table: 8 cells.
+- `revise(x, 0) == x`.
+- Learn's frozen planes are bit-identical: 8/8.
+
+**P-X19/X20** (M, mask-risc bench)
+- **X19:** MSB-first early stop vs the strided ≤ n+1 passes. PARK if the mean is ≥ 6/8 planes or the speed-up is < 1.5×.
+- **X20:** a transient bit-sliced weighted Σ vs a strided u8 gather + VNNI vs one pass per pattern, all checked against an i128 oracle.
+
+**Order:** P-X2/X5, then P-X1/X6 and P-X4, then P-X11, then P-X7/X8, then the guards, then the benches.
+
+## TO-DO vs RESEARCH vs GAP (added on operator request)
+
+**Sorting rule.**
+
+| bucket | the facts it rests on | the outcome | its acceptance test |
+|---|---|---|---|
+| **TO-DO** | already VERIFIED-IN-CODE | decided; no measurement needed to know *what* to do | fails if the work is done wrong or later regresses |
+| **RESEARCH** | — | unknown; a measurement must decide between named options | a pre-registered kill condition |
+| **GAP** | — | blocks until something exists that does not: an operator decision, a missing primitive, or missing information (a census) | — |
+
+An item may move bucket when its blocker resolves, but never silently.
+
+### TO-DO (verified facts; each has a test that can fail)
+
+| id | item | why it is a TO-DO, not research | acceptance test (can fail / stays silent) |
+|---|---|---|---|
+| T1 | Exhaustive pin of revision's c-side on all 65,536 `(c1,c2)` pairs, against the exact integer form `255·N/D`, inside `ce64_isa_golden.rs` | The code is fixed; this only records what it does. The numpy model predicts the mismatch set `{(45,45),(85,165),(165,85)}` plus `(255,255) → 0`, and the Rust run either confirms or refutes it. Both outcomes are useful, and no policy is decided. | `assert_eq!` on the exact mismatch set and on the NaN set; any cell that changes later fails. Anti-vacuity: the test asserts that the exact form is defined on 65,535 cells and undefined on exactly one. |
+| T2 | Doc line plus pin: bits 40..42 are a plane subset, not a rung ordinal | VERIFIED: `PO = 0b011` (rung 2) < `SO = 0b101` (rung 1) numerically (`pearl.rs:37-77`). The fact is known; only the guard is missing. | Test `pearl_field_is_not_a_rung_ordinal`: asserts `PO < SO` numerically AND `rung(PO) > rung(SO)`. It fails if anyone renumbers the masks to make the field ordinal, because consumers would then start thresholding it. |
+| T3 | Pin `revise(x, zero_weight)` and the operand-zero table (X16) | The contract is declared (`isa.rs:377-472`). Whether `revise(x, c=0)` returns exactly x after decode→w→encode is an observation, not a design question. | `revise(x, (f, 0)) == x` over all 65,536 `(f,c)`, or an exact list of the codes where it is not. The forward weight-operand-zero table is pinned with `==` over its 8 cells. |
+| T4 | Pin `learn`'s frozen planes as bit-identical (X17) | `isa::contracts::LEARN` declares that frozen planes pass through. This verifies the declaration against the code. | 8 plasticity patterns, with frozen planes bit-identical before and after. It fails if `learn` writes into a frozen plane. |
+| T5 | Declare the rounding mode and saturation in `isa::contracts` as data, without changing behaviour | VERIFIED: encode is `round()` (half away from zero) plus `clamp(0,1)` (`edge.rs:805-806`). Declaring what already happens is additive (firewall PASS). | The declaration is checked against T1's tie cells: a declared `HalfAwayFromZero` must reproduce the observed result at the exact .5 ties. That makes the declaration a test, not decoration; it fails if the code or the declaration drifts. |
+| T6 | File an ISSUE: "multiple truth quantisers/revisions for one concept; the planner default is confidence-blind" | Verified now: `isa` revision, contract `NarsTruth` (0.99 cap), `NarsTables` (16 bins; planner default `c_levels=1` ⇒ confidence-blind), `TruthU8` (floor). Only the diagnosis is filed, not a fix. | The ISSUE cites each `file:line`; R3 below is its measurement. |
+| T7 | Doc line: (F,C) reads as the interval `[fc, fc+1−c]`, and C is the information axis | Vocabulary only. **Not testable:** `fc ≤ f ≤ fc+1−c` is an identity, so per the falsifiability rule no test is written for it. Listed so it is not mistaken for a tested claim. | none (deliberately) |
+
+### RESEARCH (answer unknown; a measurement decides)
+
+| id | question | why it is open (what we do NOT know) | probe | kill condition |
+|---|---|---|---|---|
+| R1 | Which c=255 policy: status quo, cap-before-weight, or saturate-at-254? | We know the defect cell. We do not know whether the cap introduces new monotonicity violations near 253/254, or whether it agrees with the exact integer form everywhere else. | P-X2: the 65,536-pair grid, plus f-side at c ∈ {253, 254, 255}, under three forms | The cap gives 0 NaN, 0 violations, and agreement on all 65,535 cells ⇒ the "reserved dogmatic code" option is closed for good. Otherwise the remaining violations are listed and the operator decides (G1). |
+| R2 | Do chains of weak revisions stagnate (RN absorbs Δ) or saturate (double counting)? | Saturation was measured (200 → 224 → 237); stagnation never was. The remedies differ: round once for stagnation, a stamp gate for saturation. | P-X1/X6: chain grid, per-hop re-encode vs f64 accumulate-once vs hashed SR | stagnation = 0 ⇒ SR is dead; max Δ ≤ 1 code ⇒ "round once" is cosmetic. Anti-vacuity: some cell must move ≥ 2 codes. |
+| R3 | How far apart are the truth quantisers, numerically? | We know there are at least four and that they differ in definition. We do not know by how many codes. | P-X4: a common grid across the four | All pairs within 1 code on non-255 cells ⇒ unification is cosmetic; otherwise counts per pair. A NarsTables-1 row is predicted to diverge strongly (it ignores c). |
+| R4 | Which contradiction measure separates "both" from "balanced"? | DS K is predicted to fail on `x ⊕ x`; `K₂ = c1c2·\|f1−f2\|` is untested. Whether either is useful downstream is also unknown. | P-X11 | `K₂(x,x) ≠ 0` for any x, or `K₂((1,c),(0,c)) ≤ K₂((½,c),(½,c))` ⇒ K₂ is dead. |
+| R5 | Is the self-revision / chain saturation defect exactly "cumulative fusion applied to dependent evidence"? Does the idempotent averaging rule fix it? Is evidence-space revision invertible (fission) at 8 bits? | Jøsang gives the theory (0712.1182, read in full). Nobody has run it on the CE64 grid, and quantisation may break invertibility. | (a) re-run the measured saturating chain with averaging on dependent hops; (b) `fission(revision(a,b), b) == a` within 1 code for c < 254 | (a) no change ⇒ the dependence explanation is wrong; (b) fails ⇒ the fission reading is dropped at u8. |
+| R6 | Can D-RPF-4's weighted sum be "c→w LUT, then group-sum" exactly? Does a sequential pairwise fold agree with the closed form? | Pairwise revision is not obviously associative after per-step u8 rounding. Whether `Σw`, `Σw·f` reproduce it is unmeasured. | P-X7/X8: random populations, 100 permutations each | One distinct code per population AND equal to the closed form ⇒ an evidence terminal is unnecessary. Otherwise the exact Σ terminal is required (and G3 becomes binding). |
+| R7 | How small are D-RPF-1's minimal pattern covers really (FCA extents)? | The separable bound (24+8) is known. The real tables may be much smaller; never counted. | P-X15 plus P-X14 (threshold cover == n+1) | No reduction below 24+8 ⇒ FCA buys nothing; record the number. |
+| R8 | Is the law's PEARL table monotone under ⊆? | It is a property of data (the law tables), not of code. | P-X13 second half | Non-monotone ⇒ any future "≥" lowering over Pearl is a bug by construction (strengthens T2). |
+| R9 | Does an MSB-first early stop or a transient bit-sliced copy beat strided passes? | Literature (BitWeaving, SIMDRAM) says it can; the D-RPF-9 baseline is 1 ms/64K per pattern; no measurement exists. | P-X19, P-X20 | Mean ≥ 6/8 planes or < 1.5× ⇒ X19 is PARKED; the strided gather + VNNI path ≤ the bit-sliced one ⇒ X20 is dropped. |
+
+### GAP (blocked on something that does not exist yet)
+
+| id | gap | kind | what it blocks | what would close it |
+|---|---|---|---|---|
+| G1 | c=255 policy decision, under a version gate | operator decision (I-LEGACY: it changes what `revision` returns) | any fix of the NaN→0 defect | R1 numbers plus an operator ruling; then a gated entry point and the golden flipped from "pins defect" to "pins policy" |
+| G2 | Which truth quantiser is normative | operator / architecture decision | unification, declared readings, T5's scope | R3 numbers plus a ruling naming one reference; others become tested readings |
+| G3 | LUT-mapped strided group-sum (per-byte `c → w` table, then Σ) | missing T1 primitive in `ndarray::simd` (`MaskedStridedGroupSum` sums raw bytes only, `ir.rs:309`) | the D-RPF-4 terminal on resident rows | backend-first primitive plus an A4 differential, only if R6 shows the exact Σ terminal is needed |
+| G4 | Census: callers of `NarsTables` (2 found now), the 37 files defining `revise`/`revision`, users of `MaskedStridedGroupSum`, consumers gating on Epi5, and persisted edges holding c=255 | missing information | G1 and G2 (cannot judge blast radius) | a read pass that closes each search space by name |
+| G5 | Evidential base / stamp for independence | design gap: CE64 has no field for it and the layout is frozen; Witness ownership is open | R5's remedy; the STAMP-GATE fix | a ruling on where the stamp lives (an outside structure such as AriGraph or a tenant, never a CE64 re-read) |
+| G6 | Witness field ownership: three readings (corpus root, mailbox routing, Gomoku credit) | open ruling | G5 and any use of W as evidence identity | operator ruling |
+| G7 | Opcode taken from the operand (`forward` reads B's mantissa) | parked design change (cost M) | X18 | an additive entry point, if a consumer needs it |
+| G8 | The infographic's meanings ("activation", "novelty", "belief update") have no home | semantic gap: CONFLICTS-ANCHOR as stored bits; a new tenant is forbidden by D-RPF-8 within this plan | expressing them at all | an operator decision: derived quantities only (e.g. K₂ as "novelty"), or a separate plan for a tenant |
+| G9 | Unsearched literature and systems (see below) | research debt | confidence that nothing better exists | a follow-up scout pass if any R item hinges on it |
+
+### Order and dependencies
+
+```text
+T1 → T5 (needs T1's tie cells) ; T1 + R1 → G1 ; R3 + G4 → G2
+T2, T3, T4, T6, T7 independent
+R2 → decides X6 (SR) and X1 ; R5 needs G5 for its remedy
+R6 → G3 (only if needed) → D-RPF-4
+R7, R8 → D-RPF-1 compiler ; R9 last (bench rig)
+```
+
+## What was NOT searched
+
+- DuckDB and Velox source (FastLanes, abstract only, stood in).
+- ByteSlice beyond its abstract.
+- The official Arm ARM and RISC-V spec text (both secondhand).
+- Belnap/Kleene bit-field encodings (no source read).
+- Gustafson's posit standard and LogNet (secondhand).
+- The full bodies of `causal-plane-inventory.md` and `encoding-ecosystem.md`.
+- The callers of `NarsTables::revise`.
+- The users of `MaskedStridedGroupSum`.
+- Every consumer that gates on Epi5.
+
+"Nothing found" in these areas is not "nothing exists".
+
+## Closeout
+
+```
+PR #<tbd> | STATUS: open | OUTCOME: exploration map + 5 .arxiv harvests;
+premise split (CE64 = instruction word around a 16-bit truth number);
+no code changed | OPEN: operator choice of probes; c=255 policy; NarsTables
+caller census; Pearl-field ordinal readings to be guarded
+```
diff --git a/.claude/board/entries/README.md b/.claude/board/entries/README.md
index b8b1247ad..54eb2436f 100644
--- a/.claude/board/entries/README.md
+++ b/.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.
 
-278 entries, 2026-08-06 .. 2026-10-08.
+279 entries, 2026-08-06 .. 2026-10-08.
 
 | date | entry id | finding | file |
 |---|---|---|---|
@@ -43,6 +43,7 @@ exactly one of them, never both.
 | 2026-10-08 | `D-RPF-9` |  | [2026-10-08-fold-join-deforestation-probe.md](2026-10-08-fold-join-deforestation-probe.md) |
 | 2026-10-08 | `D-RPF-0` |  | [2026-10-08-d-rpf-0-resident-ce64-predicate.md](2026-10-08-d-rpf-0-resident-ce64-predicate.md) |
 | 2026-10-08 | `coresearch-ce64-moore-masking-wiring` |  | [2026-10-08-coresearch-ce64-moore-masking-wiring.md](2026-10-08-coresearch-ce64-moore-masking-wiring.md) |
+| 2026-10-08 | `coresearch-ce64-bf16-for-thinking` |  | [2026-10-08-coresearch-ce64-bf16-for-thinking.md](2026-10-08-coresearch-ce64-bf16-for-thinking.md) |
 | 2026-10-08 | `ce64-isa-register-contract` |  | [2026-10-08-ce64-isa-register-contract.md](2026-10-08-ce64-isa-register-contract.md) |
 | 2026-10-08 | `D-ART-1` |  | [2026-10-08-algebraic-recipe-probe.md](2026-10-08-algebraic-recipe-probe.md) |
 | 2026-10-07 | `tinker-janus-fold-harvest` | TinkerPop bulk = K (GroupReduce), ONE_BULK = S, GValue pinning = bundle invalidation; JanusGraph slice = OrderedLaneWitness→Range (30–38×); no new V4 op | [2026-10-07-tinker-janus-fold-harvest.md](2026-10-07-tinker-janus-fold-harvest.md) |