D1.2 rotation primitives + thinking-tissue north-star epiphany

First real kernel deliverable of Phase 1: RotationKernel trait + three
impls (Identity / Hadamard / OPQ-stub) with typed RotationError.
95/95 cognitive-shader-driver tests pass under --features serve
(+15 new D1.2 tests).

crates/cognitive-shader-driver/src/rotation_kernel.rs (~330 LOC):

  RotationKernel trait — object-safe, Send+Sync+Debug:
    apply(&self, &mut [f32]) -> Result<(), RotationError>
    dim() -> u32
    signature() -> u64              # feeds CodecParams::kernel_signature
    backend() -> &'static str       # "avx512" | "stub" (never "scalar")

  IdentityRotation { dim }
    — zero-overhead pass-through; apply() is a no-op

  HadamardRotation { dim }
    — REAL in-place Sylvester butterfly, O(N log N) add/sub,
      no allocations
    — validates dim is power-of-two (Sylvester requirement)
    — Rule C compliance: stays at Tier-3 F32x16 (add/sub, not matmul;
      AMX adds no value per plan appendix §12 C)
    — rustc + target-cpu=x86-64-v4 already emits AVX-512 add/sub
      from the straight-line loop → no JIT compilation needed

  OpqRotationStub { matrix_blob_id, dim }
    — real impl plugs into D1.1b CodecKernelEngine adapter +
      ndarray::hpc::jitson_cranelift::JitEngine + tile_dpbf16ps AMX
      matmul when amx_available()
    — apply() returns OpqMatrixNotLoaded (typed error) until the
      matrix-blob loader lands

  build(&Rotation, dim) -> Result<Box<dyn RotationKernel>> factory
    — dispatches on WireCodecParams.pre_rotation variant
    — returns typed errors on dim mismatch or non-pow2 Hadamard

Tests (15 new):
  Identity: noop + dim-mismatch error
  Hadamard:
    - orthogonality: H_4 · [1,0,0,0] == [1,1,1,1] (first column)
    - H · H = n · I (applying twice scales by n, verified at N=8)
    - norm² preservation up to n× scale (verified at N=16)
    - rejects non-pow2 dim (N=6)
  OPQ stub: returns OpqMatrixNotLoaded with blob_id preserved
  build(): identity / hadamard / hadamard-dim-mismatch / hadamard-
          non-pow2 / opq-stub
  Signatures: distinct across variants, stable for same shape,
             blob-id-sensitive for OPQ

Board hygiene (CLAUDE.md Mandatory rule):
  STATUS_BOARD.md:
    D1.2 Queued → In PR

  EPIPHANIES.md PREPEND (two entries):

    1. "Thinking styles ARE codecs over the semantic field"
       (north-star forward-looking deposit, not a work item)
       — codec infrastructure IS the template for production-grade
       thinking tissue. Mapping table documents the codec→thinking
       correspondence: CodecParams↔ThinkingStyleParams,
       kernel_signature↔style_signature, token_agreement↔
       conclusion_agreement, etc. Phase 5+ drops in
       WireThinkCalibrate + ThinkingStyleKernelCache using the
       same scaffolding. Generalisation isn't porting — it's
       recognising thinking styles as a SPECIAL CASE of the
       codec pattern.

    2. "D1.2 Hadamard is pure-Rust, not a JIT-necessary primitive"
       — narrows D1.1b scope by 30-40%. Only OPQ (matmul) needs
       Cranelift JIT emission; Identity (no-op) and Hadamard
       (butterfly) stay as plain-Rust Tier-3 F32x16 paths. Rustc's
       AVX-512 codegen under target-cpu=x86-64-v4 is already
       optimal for add/sub-structured kernels.

Rules honored:
  Rule A — in-place &mut [f32] slice, no allocations in apply()
  Rule B — ndarray::simd::* not needed for these shapes; compiler
           emits AVX-512 from straight-line loops
  Rule C — Hadamard stays at Tier 3 (add/sub, no AMX benefit);
           OPQ stub will route to Tier 1 AMX when matrix loaded
  Rule D — Rotation variants come from YAML via WireRotation (D0.1)
  Rule E — kernel signature() + backend() are object-methods per
           the Wire-surface-IS-SIMD-surface pattern
  Rule F — no serialization anywhere; in-memory f32 buffer only

https://claude.ai/code/session_01SbYsmmbPf9YQuYbHZN52Zh

Author: claude

.claude/board/EPIPHANIES.md

@@ -65,6 +65,82 @@ stay as historical references.
 
 ## Entries (reverse chronological)
 
+## 2026-04-20 — Thinking styles ARE codecs over the semantic field (north star)
+
+**Status:** FINDING (forward-looking deposit — not a current work item; reference when Phase 5+ generalises)
+
+A codec compresses tensor content into fingerprints; a thinking style
+compresses reasoning trajectories into NARS-revised beliefs. Same
+underlying operation — structure-preserving compression on a binary
+Hamming substrate. Different input/output domains, same substrate
+guarantees (E-SUBSTRATE-1, I-SUBSTRATE-MARKOV), same compile-and-swap
+machinery.
+
+**The codec infrastructure IS the template for production-grade
+thinking tissue.** When Phase 5+ activates:
+
+| Codec (shipped D0.1–D1.2, D1.1b queued) | Thinking-style analog |
+|---|---|
+| `CodecParams` | `ThinkingStyleParams { style, modulation_7d, nars_priors, fallback_chain, sigma_priority, semiring_choice }` |
+| `kernel_signature()` — excludes runtime drift | `style_signature()` — excludes per-cycle modulation drift |
+| `CodecKernelCache<H>` | `ThinkingStyleKernelCache<H>` — same generic scaffold |
+| JIT kernel = Cranelift-compiled decode | JIT kernel = compiled scan-walk on 36-node topology (already shipped ndarray-side via `scan_jit.rs` + `ScanParams`) |
+| **Token agreement** (I11 cert gate) | **Conclusion agreement** — same NARS-revised conclusions as reference style? |
+| Sweep grid = N codec candidates | Sweep grid = N (style × modulation × NARS fallback) candidates |
+| `/v1/shader/calibrate` | `/v1/shader/think-calibrate` |
+| `[FORMAL-SCAFFOLD]` 5 pillars | **Same scaffold** — E-SUBSTRATE-1 covers any transition under bundle |
+
+**Generalisation isn't "port codec pattern to thinking"** — it's
+recognising thinking styles as a SPECIAL CASE of the codec pattern we
+just built. When Phase 5+ lands, `WireThinkCalibrate` +
+`ThinkingStyleKernelCache` + `conclusion_agreement` metric drop in
+alongside the codec versions. Same JIT engine, same tests, same
+board-hygiene discipline.
+
+**The phrase "production-grade thinking tissue"** names the telos
+cleanly: once codec infra is at Phase 3 token-agreement pass rates,
+cloning to thinking styles yields production-grade swappable
+reasoning — YAML-configured, JIT-compiled, sweep-certified. No
+rebuild per new style, no black box, signature-keyed reproducibility.
+
+**Cross-ref:** D0.6 `CodecParams` (the parameter-shape template);
+D1.1 `CodecKernelCache<H>` (the cache pattern — generic-over-H is the
+wedge for reuse); I5 (thinking IS an AdjacencyStore — already
+topologically unified with data graph); codec-sweep-via-lab-infra-v1.
+
+---
+
+## 2026-04-20 — D1.2 Hadamard is pure-Rust, not a JIT-necessary primitive
+
+**Status:** FINDING
+
+D1.2's HadamardRotation is implemented as a plain Rust in-place
+Sylvester butterfly (O(N log N) add/sub, no allocations). It does NOT
+need JIT compilation or Cranelift code emission because:
+
+1. **Fixed shape** — the butterfly structure is identical across all
+   power-of-two dims. Rust's compiler (under `target-cpu=x86-64-v4`)
+   already emits AVX-512 add/sub from the straight-line loop.
+2. **Not matmul** — Hadamard is a pattern of adds and subtracts,
+   never a dot product. Per Rule C polyfill hierarchy, matmul-heavy
+   paths benefit from AMX (Tier 1); add/sub stays at Tier 3 F32x16.
+   AMX gives no speedup here — confirmed in plan Appendix §12 C.
+
+**Consequence for D1.1b (Cranelift wiring):** only OPQ rotation needs
+the JIT path — it's the one that's actually a learned matmul. The
+Cranelift integration scope narrows: we don't need to JIT-compile
+Identity (no-op) or Hadamard (butterfly); just OPQ (matmul) and the
+main codec decode loop (ADC distance with palette lookup).
+
+This reduces D1.1b scope by maybe 30-40% — fewer kernel shapes to
+emit, only the ones that actually benefit.
+
+Cross-ref: D1.2 `rotation_kernel.rs::HadamardRotation`; Rule C
+(polyfill hierarchy); plan Appendix B (CartanCascade harmonic
+compression ratios rely on real Hadamard, so this matters).
+
+---
+
 ## 2026-04-20 — CORRECTION to D1.1 scaffold: ndarray::hpc::jitson_cranelift already ships JitEngine
 
 **Status:** FINDING / CORRECTION

.claude/board/STATUS_BOARD.md

@@ -63,7 +63,7 @@ afterwards is a JIT kernel, not a rebuild. Plan path:
 |---|---|---|---|
 | D1.1 | `CodecKernelCache` — structural cache layer (generic over handle) | **In PR** | branch — `CodecKernelCache<H>` + `StubKernel` + `get_or_compile` / `try_get_or_compile` with RwLock concurrent-safe double-check + compile/hit/ratio counters + 9 tests. Scaffold ships NOW; D1.1b Cranelift IR emission follows. |
 | D1.1b | Adapter: `CodecKernelEngine` wrapping `ndarray::hpc::jitson_cranelift::JitEngine` with two-phase BUILD/RUN lifecycle (Arc-freeze). CodecParams → CodecScanParams adapter + codec-specific IR emission in jitson_cranelift/scan_jit analog | **Queued** | target ~250 LOC; `JitEngine` already ships (`/home/user/ndarray/src/hpc/jitson_cranelift/engine.rs`); the work is the CodecParams adapter + codec-specific JITSON template |
-| D1.2 | Rotation primitives: Identity / Hadamard / OPQ as JIT kernels | **Queued** | target ~190 LOC |
+| D1.2 | Rotation primitives: Identity / Hadamard / OPQ as `RotationKernel` impls | **In PR** | branch — `RotationKernel` trait (Send+Sync+Debug, object-safe) + `IdentityRotation` (no-op) + `HadamardRotation` (real Sylvester butterfly, O(N log N) in-place, norm²-scaling verified) + `OpqRotationStub` (matrix-blob-id placeholder for D1.1b) + `build(&Rotation, dim)` factory + `RotationError` typed errors + 15 tests. Hadamard stays at Tier-3 F32x16 (add/sub, not matmul → no AMX benefit per Rule C). |
 | D1.3 | Residual PQ via JIT composition | **Queued** | target ~150 LOC |
 
 ### Phase 2 — Token-agreement harness (I11 cert gate) — Queued

crates/cognitive-shader-driver/src/lib.rs

@@ -125,6 +125,12 @@ pub mod auto_detect;
 #[cfg(feature = "serve")]
 pub mod codec_kernel_cache;
 
+// D1.2 — rotation primitives (Identity / Hadamard / OPQ-stub). LAB-ONLY.
+// Hadamard is real (in-place butterfly); OPQ is stub pending D1.1b's
+// ndarray::hpc::jitson_cranelift::JitEngine adapter + matrix-blob loader.
+#[cfg(feature = "serve")]
+pub mod rotation_kernel;
+
 // Axum REST server. LAB-ONLY.
 #[cfg(feature = "serve")]
 pub mod serve;